1 using System;
   2 using System.Collections;
   3 using System.Text.Parsing;
   4 using cppast;
   5 
   6 // this source file has been automatically generated from 'ExpressionGrammar.parser' using cmparsergen version 2.0.0.
   7 
   8 namespace cppparser
   9 {
  10     public class ExpressionGrammar : System.Text.Parsing.Grammar
  11     {
  12         public ExpressionGrammar() : this(new ParsingDomain())
  13         {
  14         }
  15         public ExpressionGrammar(ParsingDomain* parsingDomain) : base(ToUtf32("ExpressionGrammar"), parsingDomain->GetNamespaceScope(ToUtf32("cppparser")), parsingDomain)
  16         {
  17             SetOwner(0);
  18             RegisterParsingDomain(parsingDomain);
  19             parsingDomain->AddGrammar(this);
  20             CreateRules();
  21             Link();
  22         }
  23         public ExpressionListNode* Parse(const uchar* start, const uchar* end, int fileIndex, const string& fileName, ParsingContext* ctx)
  24         {
  25             Scanner scanner(start, end, fileName, fileIndex, SkipRule());
  26             UniquePtr<XmlLog> xmlLog;
  27             if (Log() != null)
  28             {
  29                 xmlLog.Reset(new XmlLog(*Log(), MaxLogLineLength()));
  30                 scanner.SetLog(xmlLog.Get());
  31                 xmlLog->WriteBeginRule( u"parse");
  32                 xmlLog->IncIndent();
  33             }
  34             Stack<UniquePtr<Object>> stack;
  35             UniquePtr<ParsingData> parsingData(new ParsingData(Domain()->NumRules()));
  36             scanner.SetParsingData(parsingData.Get());
  37             stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(ctx)));
  38             Match match = base->Parse(scanner, stack, parsingData.Get());
  39             Span stop = scanner.GetSpan();
  40             if (Log() != null)
  41             {
  42                 xmlLog->DecIndent();
  43                 xmlLog->WriteEndRule( u"parse");
  44             }
  45             if (!match.Hit() || stop.start != cast<int>(end - start))
  46             {
  47                 if (StartRule() != null)
  48                 {
  49                     throw ExpectationFailure(StartRule()->Info(), fileName, stop, start, end);
  50                 }
  51                 else
  52                 {
  53                     throw ParsingException("grammar '" + ToUtf8(Name()) + "' has no start rule", fileName, scanner.GetSpan(), start, end);
  54                 }
  55             }
  56             UniquePtr<Object> value = stack.Pop();
  57             ExpressionListNode* result = *cast<ValueObject<ExpressionListNode*>*>(value.Get());
  58             return result;
  59         }
  60 
  61         public class ExpressionListRule : System.Text.Parsing.RuleParser
  62         {
  63             public ExpressionListRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  64             {
  65                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
  66                 SetValueTypeName(ToUtf32("ExpressionListNode*"));
  67                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<ExpressionListNode>"), ToUtf32("node")));
  68             }
  69             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  70             {
  71                 parsingData->PushContext(Id(), new Context());
  72                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  73                 UniquePtr<Object> ctx_value = stack.Pop();
  74                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
  75             }
  76             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  77             {
  78                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  79                 if (matched)
  80                 {
  81                     stack.Push(UniquePtr<Object>(new ValueObject<ExpressionListNode*>(context->value)));
  82                 }
  83                 parsingData->PopContext(Id());
  84             }
  85             public override void Link()
  86             {
  87                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  88                 a0ActionParser->SetAction(A0Action);
  89                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
  90                 a1ActionParser->SetAction(A1Action);
  91                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
  92                 a2ActionParser->SetAction(A2Action);
  93                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
  94                 a3ActionParser->SetAction(A3Action);
  95                 NonterminalParser* ic1NonterminalParser = GetNonterminal(ToUtf32("ic1"));
  96                 ic1NonterminalParser->SetPre(Preic1);
  97                 ic1NonterminalParser->SetPost(Postic1);
  98                 NonterminalParser* ic2NonterminalParser = GetNonterminal(ToUtf32("ic2"));
  99                 ic2NonterminalParser->SetPre(Preic2);
 100                 ic2NonterminalParser->SetPost(Postic2);
 101             }
 102             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 103             {
 104                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 105                 context->value = context->node.Release();
 106             }
 107             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 108             {
 109                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 110                 context->node.Reset(new ExpressionListNode(span));
 111             }
 112             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 113             {
 114                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 115                 context->node->AddNode(context->fromic1);
 116             }
 117             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 118             {
 119                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 120                 context->node->AddNode(context->fromic2);
 121             }
 122             public void Preic1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 123             {
 124                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 125                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 126             }
 127             public void Postic1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 128             {
 129                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 130                 if (matched)
 131                 {
 132                     UniquePtr<Object> fromic1_value = stack.Pop();
 133                     context->fromic1 = *cast<ValueObject<Node*>*>(fromic1_value.Get());
 134                 }
 135             }
 136             public void Preic2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 137             {
 138                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 139                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 140             }
 141             public void Postic2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 142             {
 143                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 144                 if (matched)
 145                 {
 146                     UniquePtr<Object> fromic2_value = stack.Pop();
 147                     context->fromic2 = *cast<ValueObject<Node*>*>(fromic2_value.Get());
 148                 }
 149             }
 150             public class Context : System.Text.Parsing.Context
 151             {
 152                 public Context() : ctx(), value(), node(), fromic1(), fromic2()
 153                 {
 154                 }
 155                 public ParsingContext* ctx;
 156                 public ExpressionListNode* value;
 157                 public UniquePtr<ExpressionListNode> node;
 158                 public Node* fromic1;
 159                 public Node* fromic2;
 160             }
 161         }
 162 
 163         public class PossiblyEmptyArgumentListRule : System.Text.Parsing.RuleParser
 164         {
 165             public PossiblyEmptyArgumentListRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 166             {
 167                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
 168                 SetValueTypeName(ToUtf32("ExpressionListNode*"));
 169             }
 170             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 171             {
 172                 parsingData->PushContext(Id(), new Context());
 173                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 174                 UniquePtr<Object> ctx_value = stack.Pop();
 175                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
 176             }
 177             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 178             {
 179                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 180                 if (matched)
 181                 {
 182                     stack.Push(UniquePtr<Object>(new ValueObject<ExpressionListNode*>(context->value)));
 183                 }
 184                 parsingData->PopContext(Id());
 185             }
 186             public override void Link()
 187             {
 188                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 189                 a0ActionParser->SetAction(A0Action);
 190                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 191                 a1ActionParser->SetAction(A1Action);
 192                 NonterminalParser* expressionListNonterminalParser = GetNonterminal(ToUtf32("ExpressionList"));
 193                 expressionListNonterminalParser->SetPre(PreExpressionList);
 194                 expressionListNonterminalParser->SetPost(PostExpressionList);
 195             }
 196             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 197             {
 198                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 199                 context->value = context->fromExpressionList;
 200             }
 201             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 202             {
 203                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 204                 context->value = new ExpressionListNode(span);
 205             }
 206             public void PreExpressionList(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 207             {
 208                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 209                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 210             }
 211             public void PostExpressionList(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 212             {
 213                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 214                 if (matched)
 215                 {
 216                     UniquePtr<Object> fromExpressionList_value = stack.Pop();
 217                     context->fromExpressionList = *cast<ValueObject<ExpressionListNode*>*>(fromExpressionList_value.Get());
 218                 }
 219             }
 220             public class Context : System.Text.Parsing.Context
 221             {
 222                 public Context() : ctx(), value(), fromExpressionList()
 223                 {
 224                 }
 225                 public ParsingContext* ctx;
 226                 public ExpressionListNode* value;
 227                 public ExpressionListNode* fromExpressionList;
 228             }
 229         }
 230 
 231         public class ExpressionRule : System.Text.Parsing.RuleParser
 232         {
 233             public ExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 234             {
 235                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
 236                 SetValueTypeName(ToUtf32("Node*"));
 237                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
 238             }
 239             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 240             {
 241                 parsingData->PushContext(Id(), new Context());
 242                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 243                 UniquePtr<Object> ctx_value = stack.Pop();
 244                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
 245             }
 246             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 247             {
 248                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 249                 if (matched)
 250                 {
 251                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
 252                 }
 253                 parsingData->PopContext(Id());
 254             }
 255             public override void Link()
 256             {
 257                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 258                 a0ActionParser->SetAction(A0Action);
 259                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 260                 a1ActionParser->SetAction(A1Action);
 261                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 262                 a2ActionParser->SetAction(A2Action);
 263                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 264                 leftNonterminalParser->SetPre(Preleft);
 265                 leftNonterminalParser->SetPost(Postleft);
 266                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 267                 rightNonterminalParser->SetPre(Preright);
 268                 rightNonterminalParser->SetPost(Postright);
 269             }
 270             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 271             {
 272                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 273                 context->value = context->node.Release();
 274             }
 275             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 276             {
 277                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 278                 context->node.Reset(context->fromleft);
 279             }
 280             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 281             {
 282                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 283                 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, Operator.comma));
 284             }
 285             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 286             {
 287                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 288                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 289             }
 290             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 291             {
 292                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 293                 if (matched)
 294                 {
 295                     UniquePtr<Object> fromleft_value = stack.Pop();
 296                     context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
 297                 }
 298             }
 299             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 300             {
 301                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 302                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 303             }
 304             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 305             {
 306                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 307                 if (matched)
 308                 {
 309                     UniquePtr<Object> fromright_value = stack.Pop();
 310                     context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
 311                 }
 312             }
 313             public class Context : System.Text.Parsing.Context
 314             {
 315                 public Context() : ctx(), value(), node(), fromleft(), fromright()
 316                 {
 317                 }
 318                 public ParsingContext* ctx;
 319                 public Node* value;
 320                 public UniquePtr<Node> node;
 321                 public Node* fromleft;
 322                 public Node* fromright;
 323             }
 324         }
 325 
 326         public class ConstantExpressionRule : System.Text.Parsing.RuleParser
 327         {
 328             public ConstantExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 329             {
 330                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
 331                 SetValueTypeName(ToUtf32("Node*"));
 332             }
 333             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 334             {
 335                 parsingData->PushContext(Id(), new Context());
 336                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 337                 UniquePtr<Object> ctx_value = stack.Pop();
 338                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
 339             }
 340             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 341             {
 342                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 343                 if (matched)
 344                 {
 345                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
 346                 }
 347                 parsingData->PopContext(Id());
 348             }
 349             public override void Link()
 350             {
 351                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 352                 a0ActionParser->SetAction(A0Action);
 353                 NonterminalParser* conditionalExpressionNonterminalParser = GetNonterminal(ToUtf32("ConditionalExpression"));
 354                 conditionalExpressionNonterminalParser->SetPre(PreConditionalExpression);
 355                 conditionalExpressionNonterminalParser->SetPost(PostConditionalExpression);
 356             }
 357             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 358             {
 359                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 360                 context->value = context->fromConditionalExpression;
 361             }
 362             public void PreConditionalExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 363             {
 364                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 365                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 366             }
 367             public void PostConditionalExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 368             {
 369                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 370                 if (matched)
 371                 {
 372                     UniquePtr<Object> fromConditionalExpression_value = stack.Pop();
 373                     context->fromConditionalExpression = *cast<ValueObject<Node*>*>(fromConditionalExpression_value.Get());
 374                 }
 375             }
 376             public class Context : System.Text.Parsing.Context
 377             {
 378                 public Context() : ctx(), value(), fromConditionalExpression()
 379                 {
 380                 }
 381                 public ParsingContext* ctx;
 382                 public Node* value;
 383                 public Node* fromConditionalExpression;
 384             }
 385         }
 386 
 387         public class AssignmentExpressionRule : System.Text.Parsing.RuleParser
 388         {
 389             public AssignmentExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 390             {
 391                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
 392                 SetValueTypeName(ToUtf32("Node*"));
 393             }
 394             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 395             {
 396                 parsingData->PushContext(Id(), new Context());
 397                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 398                 UniquePtr<Object> ctx_value = stack.Pop();
 399                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
 400             }
 401             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 402             {
 403                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 404                 if (matched)
 405                 {
 406                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
 407                 }
 408                 parsingData->PopContext(Id());
 409             }
 410             public override void Link()
 411             {
 412                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 413                 a0ActionParser->SetAction(A0Action);
 414                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 415                 a1ActionParser->SetAction(A1Action);
 416                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 417                 a2ActionParser->SetAction(A2Action);
 418                 NonterminalParser* concreteAssignmentExpressionNonterminalParser = GetNonterminal(ToUtf32("ConcreteAssignmentExpression"));
 419                 concreteAssignmentExpressionNonterminalParser->SetPre(PreConcreteAssignmentExpression);
 420                 concreteAssignmentExpressionNonterminalParser->SetPost(PostConcreteAssignmentExpression);
 421                 NonterminalParser* conditionalExpressionNonterminalParser = GetNonterminal(ToUtf32("ConditionalExpression"));
 422                 conditionalExpressionNonterminalParser->SetPre(PreConditionalExpression);
 423                 conditionalExpressionNonterminalParser->SetPost(PostConditionalExpression);
 424                 NonterminalParser* throwExpressionNonterminalParser = GetNonterminal(ToUtf32("ThrowExpression"));
 425                 throwExpressionNonterminalParser->SetPre(PreThrowExpression);
 426                 throwExpressionNonterminalParser->SetPost(PostThrowExpression);
 427             }
 428             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 429             {
 430                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 431                 context->value = context->fromConcreteAssignmentExpression;
 432             }
 433             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 434             {
 435                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 436                 context->value = context->fromConditionalExpression;
 437             }
 438             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 439             {
 440                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 441                 context->value = context->fromThrowExpression;
 442             }
 443             public void PreConcreteAssignmentExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 444             {
 445                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 446                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 447             }
 448             public void PostConcreteAssignmentExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 449             {
 450                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 451                 if (matched)
 452                 {
 453                     UniquePtr<Object> fromConcreteAssignmentExpression_value = stack.Pop();
 454                     context->fromConcreteAssignmentExpression = *cast<ValueObject<Node*>*>(fromConcreteAssignmentExpression_value.Get());
 455                 }
 456             }
 457             public void PreConditionalExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 458             {
 459                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 460                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 461             }
 462             public void PostConditionalExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 463             {
 464                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 465                 if (matched)
 466                 {
 467                     UniquePtr<Object> fromConditionalExpression_value = stack.Pop();
 468                     context->fromConditionalExpression = *cast<ValueObject<Node*>*>(fromConditionalExpression_value.Get());
 469                 }
 470             }
 471             public void PreThrowExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 472             {
 473                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 474                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 475             }
 476             public void PostThrowExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 477             {
 478                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 479                 if (matched)
 480                 {
 481                     UniquePtr<Object> fromThrowExpression_value = stack.Pop();
 482                     context->fromThrowExpression = *cast<ValueObject<Node*>*>(fromThrowExpression_value.Get());
 483                 }
 484             }
 485             public class Context : System.Text.Parsing.Context
 486             {
 487                 public Context() : ctx(), value(), fromConcreteAssignmentExpression(), fromConditionalExpression(), fromThrowExpression()
 488                 {
 489                 }
 490                 public ParsingContext* ctx;
 491                 public Node* value;
 492                 public Node* fromConcreteAssignmentExpression;
 493                 public Node* fromConditionalExpression;
 494                 public Node* fromThrowExpression;
 495             }
 496         }
 497 
 498         public class ConcreteAssignmentExpressionRule : System.Text.Parsing.RuleParser
 499         {
 500             public ConcreteAssignmentExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 501             {
 502                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
 503                 SetValueTypeName(ToUtf32("Node*"));
 504                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
 505             }
 506             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 507             {
 508                 parsingData->PushContext(Id(), new Context());
 509                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 510                 UniquePtr<Object> ctx_value = stack.Pop();
 511                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
 512             }
 513             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 514             {
 515                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 516                 if (matched)
 517                 {
 518                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
 519                 }
 520                 parsingData->PopContext(Id());
 521             }
 522             public override void Link()
 523             {
 524                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 525                 a0ActionParser->SetAction(A0Action);
 526                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 527                 a1ActionParser->SetAction(A1Action);
 528                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 529                 a2ActionParser->SetAction(A2Action);
 530                 a2ActionParser->SetFailure(A2ActionFail);
 531                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 532                 a3ActionParser->SetAction(A3Action);
 533                 NonterminalParser* logicalOrExpressionNonterminalParser = GetNonterminal(ToUtf32("LogicalOrExpression"));
 534                 logicalOrExpressionNonterminalParser->SetPre(PreLogicalOrExpression);
 535                 logicalOrExpressionNonterminalParser->SetPost(PostLogicalOrExpression);
 536                 NonterminalParser* assignmentOperatorNonterminalParser = GetNonterminal(ToUtf32("AssignmentOperator"));
 537                 assignmentOperatorNonterminalParser->SetPost(PostAssignmentOperator);
 538                 NonterminalParser* initializerClauseNonterminalParser = GetNonterminal(ToUtf32("InitializerClause"));
 539                 initializerClauseNonterminalParser->SetPre(PreInitializerClause);
 540                 initializerClauseNonterminalParser->SetPost(PostInitializerClause);
 541             }
 542             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 543             {
 544                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 545                 context->ctx->BeginParsingLvalue();
 546             }
 547             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 548             {
 549                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 550                 context->value = context->node.Release();
 551             }
 552             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 553             {
 554                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 555                 context->node.Reset(context->fromLogicalOrExpression);
 556                 context->ctx->EndParsingLvalue();
 557             }
 558             public void A2ActionFail(ParsingData* parsingData)
 559             {
 560                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 561                 context->ctx->EndParsingLvalue();
 562             }
 563             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 564             {
 565                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 566                 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromInitializerClause, context->fromAssignmentOperator));
 567             }
 568             public void PreLogicalOrExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 569             {
 570                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 571                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 572             }
 573             public void PostLogicalOrExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 574             {
 575                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 576                 if (matched)
 577                 {
 578                     UniquePtr<Object> fromLogicalOrExpression_value = stack.Pop();
 579                     context->fromLogicalOrExpression = *cast<ValueObject<Node*>*>(fromLogicalOrExpression_value.Get());
 580                 }
 581             }
 582             public void PostAssignmentOperator(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 583             {
 584                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 585                 if (matched)
 586                 {
 587                     UniquePtr<Object> fromAssignmentOperator_value = stack.Pop();
 588                     context->fromAssignmentOperator = *cast<ValueObject<Operator>*>(fromAssignmentOperator_value.Get());
 589                 }
 590             }
 591             public void PreInitializerClause(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 592             {
 593                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 594                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 595             }
 596             public void PostInitializerClause(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 597             {
 598                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 599                 if (matched)
 600                 {
 601                     UniquePtr<Object> fromInitializerClause_value = stack.Pop();
 602                     context->fromInitializerClause = *cast<ValueObject<Node*>*>(fromInitializerClause_value.Get());
 603                 }
 604             }
 605             public class Context : System.Text.Parsing.Context
 606             {
 607                 public Context() : ctx(), value(), node(), fromLogicalOrExpression(), fromAssignmentOperator(), fromInitializerClause()
 608                 {
 609                 }
 610                 public ParsingContext* ctx;
 611                 public Node* value;
 612                 public UniquePtr<Node> node;
 613                 public Node* fromLogicalOrExpression;
 614                 public Operator fromAssignmentOperator;
 615                 public Node* fromInitializerClause;
 616             }
 617         }
 618 
 619         public class AssignmentOperatorRule : System.Text.Parsing.RuleParser
 620         {
 621             public AssignmentOperatorRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 622             {
 623                 SetValueTypeName(ToUtf32("Operator"));
 624             }
 625             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 626             {
 627                 parsingData->PushContext(Id(), new Context());
 628                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 629             }
 630             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 631             {
 632                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 633                 if (matched)
 634                 {
 635                     stack.Push(UniquePtr<Object>(new ValueObject<Operator>(context->value)));
 636                 }
 637                 parsingData->PopContext(Id());
 638             }
 639             public override void Link()
 640             {
 641                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 642                 a0ActionParser->SetAction(A0Action);
 643                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 644                 a1ActionParser->SetAction(A1Action);
 645                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 646                 a2ActionParser->SetAction(A2Action);
 647                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 648                 a3ActionParser->SetAction(A3Action);
 649                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
 650                 a4ActionParser->SetAction(A4Action);
 651                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
 652                 a5ActionParser->SetAction(A5Action);
 653                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
 654                 a6ActionParser->SetAction(A6Action);
 655                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
 656                 a7ActionParser->SetAction(A7Action);
 657                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
 658                 a8ActionParser->SetAction(A8Action);
 659                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
 660                 a9ActionParser->SetAction(A9Action);
 661                 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
 662                 a10ActionParser->SetAction(A10Action);
 663             }
 664             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 665             {
 666                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 667                 context->value = Operator.assign;
 668             }
 669             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 670             {
 671                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 672                 context->value = Operator.mulAssign;
 673             }
 674             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 675             {
 676                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 677                 context->value = Operator.divAssign;
 678             }
 679             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 680             {
 681                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 682                 context->value = Operator.remAssign;
 683             }
 684             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 685             {
 686                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 687                 context->value = Operator.addAssign;
 688             }
 689             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 690             {
 691                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 692                 context->value = Operator.subAssign;
 693             }
 694             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 695             {
 696                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 697                 context->value = Operator.shiftRightAssign;
 698             }
 699             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 700             {
 701                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 702                 context->value = Operator.shiftLeftAssign;
 703             }
 704             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 705             {
 706                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 707                 context->value = Operator.andAssign;
 708             }
 709             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 710             {
 711                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 712                 context->value = Operator.xorAssign;
 713             }
 714             public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 715             {
 716                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 717                 context->value = Operator.orAssign;
 718             }
 719             public class Context : System.Text.Parsing.Context
 720             {
 721                 public Context() : value()
 722                 {
 723                 }
 724                 public Operator value;
 725             }
 726         }
 727 
 728         public class ConditionalExpressionRule : System.Text.Parsing.RuleParser
 729         {
 730             public ConditionalExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 731             {
 732                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
 733                 SetValueTypeName(ToUtf32("Node*"));
 734                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
 735             }
 736             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 737             {
 738                 parsingData->PushContext(Id(), new Context());
 739                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 740                 UniquePtr<Object> ctx_value = stack.Pop();
 741                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
 742             }
 743             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 744             {
 745                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 746                 if (matched)
 747                 {
 748                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
 749                 }
 750                 parsingData->PopContext(Id());
 751             }
 752             public override void Link()
 753             {
 754                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 755                 a0ActionParser->SetAction(A0Action);
 756                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 757                 a1ActionParser->SetAction(A1Action);
 758                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 759                 a2ActionParser->SetAction(A2Action);
 760                 NonterminalParser* logicalOrExpressionNonterminalParser = GetNonterminal(ToUtf32("LogicalOrExpression"));
 761                 logicalOrExpressionNonterminalParser->SetPre(PreLogicalOrExpression);
 762                 logicalOrExpressionNonterminalParser->SetPost(PostLogicalOrExpression);
 763                 NonterminalParser* expressionNonterminalParser = GetNonterminal(ToUtf32("Expression"));
 764                 expressionNonterminalParser->SetPre(PreExpression);
 765                 expressionNonterminalParser->SetPost(PostExpression);
 766                 NonterminalParser* assignmentExpressionNonterminalParser = GetNonterminal(ToUtf32("AssignmentExpression"));
 767                 assignmentExpressionNonterminalParser->SetPre(PreAssignmentExpression);
 768                 assignmentExpressionNonterminalParser->SetPost(PostAssignmentExpression);
 769             }
 770             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 771             {
 772                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 773                 context->value = context->node.Release();
 774             }
 775             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 776             {
 777                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 778                 context->node.Reset(context->fromLogicalOrExpression);
 779             }
 780             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 781             {
 782                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 783                 context->node.Reset(new ConditionalExpressionNode(span, context->node.Release(), context->fromExpression, context->fromAssignmentExpression));
 784             }
 785             public void PreLogicalOrExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 786             {
 787                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 788                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 789             }
 790             public void PostLogicalOrExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 791             {
 792                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 793                 if (matched)
 794                 {
 795                     UniquePtr<Object> fromLogicalOrExpression_value = stack.Pop();
 796                     context->fromLogicalOrExpression = *cast<ValueObject<Node*>*>(fromLogicalOrExpression_value.Get());
 797                 }
 798             }
 799             public void PreExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 800             {
 801                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 802                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 803             }
 804             public void PostExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 805             {
 806                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 807                 if (matched)
 808                 {
 809                     UniquePtr<Object> fromExpression_value = stack.Pop();
 810                     context->fromExpression = *cast<ValueObject<Node*>*>(fromExpression_value.Get());
 811                 }
 812             }
 813             public void PreAssignmentExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 814             {
 815                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 816                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 817             }
 818             public void PostAssignmentExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 819             {
 820                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 821                 if (matched)
 822                 {
 823                     UniquePtr<Object> fromAssignmentExpression_value = stack.Pop();
 824                     context->fromAssignmentExpression = *cast<ValueObject<Node*>*>(fromAssignmentExpression_value.Get());
 825                 }
 826             }
 827             public class Context : System.Text.Parsing.Context
 828             {
 829                 public Context() : ctx(), value(), node(), fromLogicalOrExpression(), fromExpression(), fromAssignmentExpression()
 830                 {
 831                 }
 832                 public ParsingContext* ctx;
 833                 public Node* value;
 834                 public UniquePtr<Node> node;
 835                 public Node* fromLogicalOrExpression;
 836                 public Node* fromExpression;
 837                 public Node* fromAssignmentExpression;
 838             }
 839         }
 840 
 841         public class ThrowExpressionRule : System.Text.Parsing.RuleParser
 842         {
 843             public ThrowExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 844             {
 845                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
 846                 SetValueTypeName(ToUtf32("Node*"));
 847             }
 848             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 849             {
 850                 parsingData->PushContext(Id(), new Context());
 851                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 852                 UniquePtr<Object> ctx_value = stack.Pop();
 853                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
 854             }
 855             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 856             {
 857                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 858                 if (matched)
 859                 {
 860                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
 861                 }
 862                 parsingData->PopContext(Id());
 863             }
 864             public override void Link()
 865             {
 866                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 867                 a0ActionParser->SetAction(A0Action);
 868                 NonterminalParser* assignmentExpressionNonterminalParser = GetNonterminal(ToUtf32("AssignmentExpression"));
 869                 assignmentExpressionNonterminalParser->SetPre(PreAssignmentExpression);
 870                 assignmentExpressionNonterminalParser->SetPost(PostAssignmentExpression);
 871             }
 872             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 873             {
 874                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 875                 context->value = new ThrowExpressionNode(span, context->fromAssignmentExpression);
 876             }
 877             public void PreAssignmentExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 878             {
 879                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 880                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 881             }
 882             public void PostAssignmentExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 883             {
 884                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 885                 if (matched)
 886                 {
 887                     UniquePtr<Object> fromAssignmentExpression_value = stack.Pop();
 888                     context->fromAssignmentExpression = *cast<ValueObject<Node*>*>(fromAssignmentExpression_value.Get());
 889                 }
 890             }
 891             public class Context : System.Text.Parsing.Context
 892             {
 893                 public Context() : ctx(), value(), fromAssignmentExpression()
 894                 {
 895                 }
 896                 public ParsingContext* ctx;
 897                 public Node* value;
 898                 public Node* fromAssignmentExpression;
 899             }
 900         }
 901 
 902         public class LogicalOrExpressionRule : System.Text.Parsing.RuleParser
 903         {
 904             public LogicalOrExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 905             {
 906                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
 907                 SetValueTypeName(ToUtf32("Node*"));
 908                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
 909             }
 910             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 911             {
 912                 parsingData->PushContext(Id(), new Context());
 913                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 914                 UniquePtr<Object> ctx_value = stack.Pop();
 915                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
 916             }
 917             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 918             {
 919                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 920                 if (matched)
 921                 {
 922                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
 923                 }
 924                 parsingData->PopContext(Id());
 925             }
 926             public override void Link()
 927             {
 928                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 929                 a0ActionParser->SetAction(A0Action);
 930                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 931                 a1ActionParser->SetAction(A1Action);
 932                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 933                 a2ActionParser->SetAction(A2Action);
 934                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 935                 a3ActionParser->SetAction(A3Action);
 936                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 937                 leftNonterminalParser->SetPre(Preleft);
 938                 leftNonterminalParser->SetPost(Postleft);
 939                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 940                 rightNonterminalParser->SetPre(Preright);
 941                 rightNonterminalParser->SetPost(Postright);
 942             }
 943             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 944             {
 945                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 946                 context->value = context->node.Release();
 947             }
 948             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 949             {
 950                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 951                 context->node.Reset(context->fromleft);
 952             }
 953             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 954             {
 955                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 956                 if (context->ctx->ParsingTemplateIdOrLvalueAndNotArguments()) pass = false;
 957             }
 958             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 959             {
 960                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 961                 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, Operator.logicalOr));
 962             }
 963             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 964             {
 965                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 966                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 967             }
 968             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 969             {
 970                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 971                 if (matched)
 972                 {
 973                     UniquePtr<Object> fromleft_value = stack.Pop();
 974                     context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
 975                 }
 976             }
 977             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 978             {
 979                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 980                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
 981             }
 982             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 983             {
 984                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 985                 if (matched)
 986                 {
 987                     UniquePtr<Object> fromright_value = stack.Pop();
 988                     context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
 989                 }
 990             }
 991             public class Context : System.Text.Parsing.Context
 992             {
 993                 public Context() : ctx(), value(), node(), fromleft(), fromright()
 994                 {
 995                 }
 996                 public ParsingContext* ctx;
 997                 public Node* value;
 998                 public UniquePtr<Node> node;
 999                 public Node* fromleft;
1000                 public Node* fromright;
1001             }
1002         }
1003 
1004         public class LogicalAndExpressionRule : System.Text.Parsing.RuleParser
1005         {
1006             public LogicalAndExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1007             {
1008                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1009                 SetValueTypeName(ToUtf32("Node*"));
1010                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1011             }
1012             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1013             {
1014                 parsingData->PushContext(Id(), new Context());
1015                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1016                 UniquePtr<Object> ctx_value = stack.Pop();
1017                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1018             }
1019             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1020             {
1021                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1022                 if (matched)
1023                 {
1024                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1025                 }
1026                 parsingData->PopContext(Id());
1027             }
1028             public override void Link()
1029             {
1030                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1031                 a0ActionParser->SetAction(A0Action);
1032                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1033                 a1ActionParser->SetAction(A1Action);
1034                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1035                 a2ActionParser->SetAction(A2Action);
1036                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1037                 a3ActionParser->SetAction(A3Action);
1038                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1039                 leftNonterminalParser->SetPre(Preleft);
1040                 leftNonterminalParser->SetPost(Postleft);
1041                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1042                 rightNonterminalParser->SetPre(Preright);
1043                 rightNonterminalParser->SetPost(Postright);
1044             }
1045             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1046             {
1047                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1048                 context->value = context->node.Release();
1049             }
1050             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1051             {
1052                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1053                 context->node.Reset(context->fromleft);
1054             }
1055             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1056             {
1057                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1058                 if (context->ctx->ParsingTemplateIdOrLvalueAndNotArguments()) pass = false;
1059             }
1060             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1061             {
1062                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1063                 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, Operator.logicalAnd));
1064             }
1065             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1066             {
1067                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1068                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1069             }
1070             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1071             {
1072                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1073                 if (matched)
1074                 {
1075                     UniquePtr<Object> fromleft_value = stack.Pop();
1076                     context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1077                 }
1078             }
1079             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1080             {
1081                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1082                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1083             }
1084             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1085             {
1086                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1087                 if (matched)
1088                 {
1089                     UniquePtr<Object> fromright_value = stack.Pop();
1090                     context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1091                 }
1092             }
1093             public class Context : System.Text.Parsing.Context
1094             {
1095                 public Context() : ctx(), value(), node(), fromleft(), fromright()
1096                 {
1097                 }
1098                 public ParsingContext* ctx;
1099                 public Node* value;
1100                 public UniquePtr<Node> node;
1101                 public Node* fromleft;
1102                 public Node* fromright;
1103             }
1104         }
1105 
1106         public class InclusiveOrExpressionRule : System.Text.Parsing.RuleParser
1107         {
1108             public InclusiveOrExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1109             {
1110                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1111                 SetValueTypeName(ToUtf32("Node*"));
1112                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1113             }
1114             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1115             {
1116                 parsingData->PushContext(Id(), new Context());
1117                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1118                 UniquePtr<Object> ctx_value = stack.Pop();
1119                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1120             }
1121             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1122             {
1123                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1124                 if (matched)
1125                 {
1126                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1127                 }
1128                 parsingData->PopContext(Id());
1129             }
1130             public override void Link()
1131             {
1132                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1133                 a0ActionParser->SetAction(A0Action);
1134                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1135                 a1ActionParser->SetAction(A1Action);
1136                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1137                 a2ActionParser->SetAction(A2Action);
1138                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1139                 a3ActionParser->SetAction(A3Action);
1140                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1141                 leftNonterminalParser->SetPre(Preleft);
1142                 leftNonterminalParser->SetPost(Postleft);
1143                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1144                 rightNonterminalParser->SetPre(Preright);
1145                 rightNonterminalParser->SetPost(Postright);
1146             }
1147             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1148             {
1149                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1150                 context->value = context->node.Release();
1151             }
1152             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1153             {
1154                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1155                 context->node.Reset(context->fromleft);
1156             }
1157             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1158             {
1159                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1160                 if (context->ctx->ParsingLvalueAndNotArguments()) pass = false;
1161             }
1162             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1163             {
1164                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1165                 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, Operator.or_));
1166             }
1167             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1168             {
1169                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1170                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1171             }
1172             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1173             {
1174                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1175                 if (matched)
1176                 {
1177                     UniquePtr<Object> fromleft_value = stack.Pop();
1178                     context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1179                 }
1180             }
1181             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1182             {
1183                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1184                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1185             }
1186             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1187             {
1188                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1189                 if (matched)
1190                 {
1191                     UniquePtr<Object> fromright_value = stack.Pop();
1192                     context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1193                 }
1194             }
1195             public class Context : System.Text.Parsing.Context
1196             {
1197                 public Context() : ctx(), value(), node(), fromleft(), fromright()
1198                 {
1199                 }
1200                 public ParsingContext* ctx;
1201                 public Node* value;
1202                 public UniquePtr<Node> node;
1203                 public Node* fromleft;
1204                 public Node* fromright;
1205             }
1206         }
1207 
1208         public class ExclusiveOrExpressionRule : System.Text.Parsing.RuleParser
1209         {
1210             public ExclusiveOrExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1211             {
1212                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1213                 SetValueTypeName(ToUtf32("Node*"));
1214                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1215             }
1216             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1217             {
1218                 parsingData->PushContext(Id(), new Context());
1219                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1220                 UniquePtr<Object> ctx_value = stack.Pop();
1221                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1222             }
1223             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1224             {
1225                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1226                 if (matched)
1227                 {
1228                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1229                 }
1230                 parsingData->PopContext(Id());
1231             }
1232             public override void Link()
1233             {
1234                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1235                 a0ActionParser->SetAction(A0Action);
1236                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1237                 a1ActionParser->SetAction(A1Action);
1238                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1239                 a2ActionParser->SetAction(A2Action);
1240                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1241                 a3ActionParser->SetAction(A3Action);
1242                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1243                 leftNonterminalParser->SetPre(Preleft);
1244                 leftNonterminalParser->SetPost(Postleft);
1245                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1246                 rightNonterminalParser->SetPre(Preright);
1247                 rightNonterminalParser->SetPost(Postright);
1248             }
1249             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1250             {
1251                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1252                 context->value = context->node.Release();
1253             }
1254             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1255             {
1256                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1257                 context->node.Reset(context->fromleft);
1258             }
1259             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1260             {
1261                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1262                 if (context->ctx->ParsingLvalueAndNotArguments()) pass = false;
1263             }
1264             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1265             {
1266                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1267                 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, Operator.xor));
1268             }
1269             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1270             {
1271                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1272                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1273             }
1274             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1275             {
1276                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1277                 if (matched)
1278                 {
1279                     UniquePtr<Object> fromleft_value = stack.Pop();
1280                     context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1281                 }
1282             }
1283             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1284             {
1285                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1286                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1287             }
1288             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1289             {
1290                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1291                 if (matched)
1292                 {
1293                     UniquePtr<Object> fromright_value = stack.Pop();
1294                     context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1295                 }
1296             }
1297             public class Context : System.Text.Parsing.Context
1298             {
1299                 public Context() : ctx(), value(), node(), fromleft(), fromright()
1300                 {
1301                 }
1302                 public ParsingContext* ctx;
1303                 public Node* value;
1304                 public UniquePtr<Node> node;
1305                 public Node* fromleft;
1306                 public Node* fromright;
1307             }
1308         }
1309 
1310         public class AndExpressionRule : System.Text.Parsing.RuleParser
1311         {
1312             public AndExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1313             {
1314                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1315                 SetValueTypeName(ToUtf32("Node*"));
1316                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1317             }
1318             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1319             {
1320                 parsingData->PushContext(Id(), new Context());
1321                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1322                 UniquePtr<Object> ctx_value = stack.Pop();
1323                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1324             }
1325             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1326             {
1327                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1328                 if (matched)
1329                 {
1330                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1331                 }
1332                 parsingData->PopContext(Id());
1333             }
1334             public override void Link()
1335             {
1336                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1337                 a0ActionParser->SetAction(A0Action);
1338                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1339                 a1ActionParser->SetAction(A1Action);
1340                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1341                 a2ActionParser->SetAction(A2Action);
1342                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1343                 a3ActionParser->SetAction(A3Action);
1344                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1345                 leftNonterminalParser->SetPre(Preleft);
1346                 leftNonterminalParser->SetPost(Postleft);
1347                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1348                 rightNonterminalParser->SetPre(Preright);
1349                 rightNonterminalParser->SetPost(Postright);
1350             }
1351             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1352             {
1353                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1354                 context->value = context->node.Release();
1355             }
1356             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1357             {
1358                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1359                 context->node.Reset(context->fromleft);
1360             }
1361             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1362             {
1363                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1364                 if (context->ctx->ParsingLvalueAndNotArguments()) pass = false;
1365             }
1366             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1367             {
1368                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1369                 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, Operator.and_));
1370             }
1371             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1372             {
1373                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1374                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1375             }
1376             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1377             {
1378                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1379                 if (matched)
1380                 {
1381                     UniquePtr<Object> fromleft_value = stack.Pop();
1382                     context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1383                 }
1384             }
1385             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1386             {
1387                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1388                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1389             }
1390             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1391             {
1392                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1393                 if (matched)
1394                 {
1395                     UniquePtr<Object> fromright_value = stack.Pop();
1396                     context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1397                 }
1398             }
1399             public class Context : System.Text.Parsing.Context
1400             {
1401                 public Context() : ctx(), value(), node(), fromleft(), fromright()
1402                 {
1403                 }
1404                 public ParsingContext* ctx;
1405                 public Node* value;
1406                 public UniquePtr<Node> node;
1407                 public Node* fromleft;
1408                 public Node* fromright;
1409             }
1410         }
1411 
1412         public class EqualityExpressionRule : System.Text.Parsing.RuleParser
1413         {
1414             public EqualityExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1415             {
1416                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1417                 SetValueTypeName(ToUtf32("Node*"));
1418                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1419                 AddLocalVariable(AttrOrVar(ToUtf32("Operator"), ToUtf32("op")));
1420             }
1421             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1422             {
1423                 parsingData->PushContext(Id(), new Context());
1424                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1425                 UniquePtr<Object> ctx_value = stack.Pop();
1426                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1427             }
1428             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1429             {
1430                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1431                 if (matched)
1432                 {
1433                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1434                 }
1435                 parsingData->PopContext(Id());
1436             }
1437             public override void Link()
1438             {
1439                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1440                 a0ActionParser->SetAction(A0Action);
1441                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1442                 a1ActionParser->SetAction(A1Action);
1443                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1444                 a2ActionParser->SetAction(A2Action);
1445                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1446                 a3ActionParser->SetAction(A3Action);
1447                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
1448                 a4ActionParser->SetAction(A4Action);
1449                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
1450                 a5ActionParser->SetAction(A5Action);
1451                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1452                 leftNonterminalParser->SetPre(Preleft);
1453                 leftNonterminalParser->SetPost(Postleft);
1454                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1455                 rightNonterminalParser->SetPre(Preright);
1456                 rightNonterminalParser->SetPost(Postright);
1457             }
1458             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1459             {
1460                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1461                 context->value = context->node.Release();
1462             }
1463             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1464             {
1465                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1466                 context->node.Reset(context->fromleft);
1467             }
1468             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1469             {
1470                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1471                 if (context->ctx->ParsingLvalueAndNotArguments()) pass = false;
1472             }
1473             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1474             {
1475                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1476                 context->op = Operator.equal;
1477             }
1478             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1479             {
1480                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1481                 context->op = Operator.notEqual;
1482             }
1483             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1484             {
1485                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1486                 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, context->op));
1487             }
1488             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1489             {
1490                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1491                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1492             }
1493             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1494             {
1495                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1496                 if (matched)
1497                 {
1498                     UniquePtr<Object> fromleft_value = stack.Pop();
1499                     context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1500                 }
1501             }
1502             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1503             {
1504                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1505                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1506             }
1507             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1508             {
1509                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1510                 if (matched)
1511                 {
1512                     UniquePtr<Object> fromright_value = stack.Pop();
1513                     context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1514                 }
1515             }
1516             public class Context : System.Text.Parsing.Context
1517             {
1518                 public Context() : ctx(), value(), node(), op(), fromleft(), fromright()
1519                 {
1520                 }
1521                 public ParsingContext* ctx;
1522                 public Node* value;
1523                 public UniquePtr<Node> node;
1524                 public Operator op;
1525                 public Node* fromleft;
1526                 public Node* fromright;
1527             }
1528         }
1529 
1530         public class RelationalExpressionRule : System.Text.Parsing.RuleParser
1531         {
1532             public RelationalExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1533             {
1534                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1535                 SetValueTypeName(ToUtf32("Node*"));
1536                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1537                 AddLocalVariable(AttrOrVar(ToUtf32("Operator"), ToUtf32("op")));
1538             }
1539             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1540             {
1541                 parsingData->PushContext(Id(), new Context());
1542                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1543                 UniquePtr<Object> ctx_value = stack.Pop();
1544                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1545             }
1546             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1547             {
1548                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1549                 if (matched)
1550                 {
1551                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1552                 }
1553                 parsingData->PopContext(Id());
1554             }
1555             public override void Link()
1556             {
1557                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1558                 a0ActionParser->SetAction(A0Action);
1559                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1560                 a1ActionParser->SetAction(A1Action);
1561                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1562                 a2ActionParser->SetAction(A2Action);
1563                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1564                 a3ActionParser->SetAction(A3Action);
1565                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
1566                 a4ActionParser->SetAction(A4Action);
1567                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
1568                 a5ActionParser->SetAction(A5Action);
1569                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
1570                 a6ActionParser->SetAction(A6Action);
1571                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
1572                 a7ActionParser->SetAction(A7Action);
1573                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1574                 leftNonterminalParser->SetPre(Preleft);
1575                 leftNonterminalParser->SetPost(Postleft);
1576                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1577                 rightNonterminalParser->SetPre(Preright);
1578                 rightNonterminalParser->SetPost(Postright);
1579             }
1580             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1581             {
1582                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1583                 context->value = context->node.Release();
1584             }
1585             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1586             {
1587                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1588                 context->node.Reset(context->fromleft);
1589             }
1590             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1591             {
1592                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1593                 if (context->ctx->ParsingTemplateIdOrLvalueAndNotArguments()) pass = false;
1594             }
1595             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1596             {
1597                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1598                 context->op = Operator.lessOrEqual;
1599             }
1600             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1601             {
1602                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1603                 context->op = Operator.greaterOrEqual;
1604             }
1605             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1606             {
1607                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1608                 context->op = Operator.less;
1609             }
1610             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1611             {
1612                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1613                 context->op = Operator.greater;
1614             }
1615             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1616             {
1617                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1618                 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, context->op));
1619             }
1620             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1621             {
1622                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1623                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1624             }
1625             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1626             {
1627                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1628                 if (matched)
1629                 {
1630                     UniquePtr<Object> fromleft_value = stack.Pop();
1631                     context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1632                 }
1633             }
1634             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1635             {
1636                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1637                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1638             }
1639             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1640             {
1641                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1642                 if (matched)
1643                 {
1644                     UniquePtr<Object> fromright_value = stack.Pop();
1645                     context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1646                 }
1647             }
1648             public class Context : System.Text.Parsing.Context
1649             {
1650                 public Context() : ctx(), value(), node(), op(), fromleft(), fromright()
1651                 {
1652                 }
1653                 public ParsingContext* ctx;
1654                 public Node* value;
1655                 public UniquePtr<Node> node;
1656                 public Operator op;
1657                 public Node* fromleft;
1658                 public Node* fromright;
1659             }
1660         }
1661 
1662         public class ShiftExpressionRule : System.Text.Parsing.RuleParser
1663         {
1664             public ShiftExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1665             {
1666                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1667                 SetValueTypeName(ToUtf32("Node*"));
1668                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1669                 AddLocalVariable(AttrOrVar(ToUtf32("Operator"), ToUtf32("op")));
1670             }
1671             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1672             {
1673                 parsingData->PushContext(Id(), new Context());
1674                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1675                 UniquePtr<Object> ctx_value = stack.Pop();
1676                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1677             }
1678             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1679             {
1680                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1681                 if (matched)
1682                 {
1683                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1684                 }
1685                 parsingData->PopContext(Id());
1686             }
1687             public override void Link()
1688             {
1689                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1690                 a0ActionParser->SetAction(A0Action);
1691                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1692                 a1ActionParser->SetAction(A1Action);
1693                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1694                 a2ActionParser->SetAction(A2Action);
1695                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1696                 a3ActionParser->SetAction(A3Action);
1697                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
1698                 a4ActionParser->SetAction(A4Action);
1699                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
1700                 a5ActionParser->SetAction(A5Action);
1701                 a5ActionParser->SetFailure(A5ActionFail);
1702                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1703                 leftNonterminalParser->SetPre(Preleft);
1704                 leftNonterminalParser->SetPost(Postleft);
1705                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1706                 rightNonterminalParser->SetPre(Preright);
1707                 rightNonterminalParser->SetPost(Postright);
1708             }
1709             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1710             {
1711                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1712                 context->value = context->node.Release();
1713             }
1714             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1715             {
1716                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1717                 context->node.Reset(context->fromleft);
1718             }
1719             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1720             {
1721                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1722                 context->ctx->BeginParsingArguments();
1723             }
1724             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1725             {
1726                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1727                 context->op = Operator.shiftLeft;
1728             }
1729             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1730             {
1731                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1732                 context->op = Operator.shiftRight;
1733             }
1734             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1735             {
1736                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1737                 context->ctx->EndParsingArguments();
1738                 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, context->op));
1739             }
1740             public void A5ActionFail(ParsingData* parsingData)
1741             {
1742                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1743                 context->ctx->EndParsingArguments();
1744             }
1745             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1746             {
1747                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1748                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1749             }
1750             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1751             {
1752                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1753                 if (matched)
1754                 {
1755                     UniquePtr<Object> fromleft_value = stack.Pop();
1756                     context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1757                 }
1758             }
1759             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1760             {
1761                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1762                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1763             }
1764             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1765             {
1766                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1767                 if (matched)
1768                 {
1769                     UniquePtr<Object> fromright_value = stack.Pop();
1770                     context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1771                 }
1772             }
1773             public class Context : System.Text.Parsing.Context
1774             {
1775                 public Context() : ctx(), value(), node(), op(), fromleft(), fromright()
1776                 {
1777                 }
1778                 public ParsingContext* ctx;
1779                 public Node* value;
1780                 public UniquePtr<Node> node;
1781                 public Operator op;
1782                 public Node* fromleft;
1783                 public Node* fromright;
1784             }
1785         }
1786 
1787         public class AdditiveExpressionRule : System.Text.Parsing.RuleParser
1788         {
1789             public AdditiveExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1790             {
1791                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1792                 SetValueTypeName(ToUtf32("Node*"));
1793                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1794                 AddLocalVariable(AttrOrVar(ToUtf32("Operator"), ToUtf32("op")));
1795             }
1796             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1797             {
1798                 parsingData->PushContext(Id(), new Context());
1799                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1800                 UniquePtr<Object> ctx_value = stack.Pop();
1801                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1802             }
1803             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1804             {
1805                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1806                 if (matched)
1807                 {
1808                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1809                 }
1810                 parsingData->PopContext(Id());
1811             }
1812             public override void Link()
1813             {
1814                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1815                 a0ActionParser->SetAction(A0Action);
1816                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1817                 a1ActionParser->SetAction(A1Action);
1818                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1819                 a2ActionParser->SetAction(A2Action);
1820                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1821                 a3ActionParser->SetAction(A3Action);
1822                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
1823                 a4ActionParser->SetAction(A4Action);
1824                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
1825                 a5ActionParser->SetAction(A5Action);
1826                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1827                 leftNonterminalParser->SetPre(Preleft);
1828                 leftNonterminalParser->SetPost(Postleft);
1829                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1830                 rightNonterminalParser->SetPre(Preright);
1831                 rightNonterminalParser->SetPost(Postright);
1832             }
1833             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1834             {
1835                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1836                 context->value = context->node.Release();
1837             }
1838             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1839             {
1840                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1841                 context->node.Reset(context->fromleft);
1842             }
1843             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1844             {
1845                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1846                 if (context->ctx->ParsingLvalueAndNotArguments()) pass = false;
1847             }
1848             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1849             {
1850                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1851                 context->op = Operator.add;
1852             }
1853             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1854             {
1855                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1856                 context->op = Operator.sub;
1857             }
1858             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1859             {
1860                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1861                 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, context->op));
1862             }
1863             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1864             {
1865                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1866                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1867             }
1868             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1869             {
1870                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1871                 if (matched)
1872                 {
1873                     UniquePtr<Object> fromleft_value = stack.Pop();
1874                     context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1875                 }
1876             }
1877             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1878             {
1879                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1880                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1881             }
1882             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1883             {
1884                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1885                 if (matched)
1886                 {
1887                     UniquePtr<Object> fromright_value = stack.Pop();
1888                     context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1889                 }
1890             }
1891             public class Context : System.Text.Parsing.Context
1892             {
1893                 public Context() : ctx(), value(), node(), op(), fromleft(), fromright()
1894                 {
1895                 }
1896                 public ParsingContext* ctx;
1897                 public Node* value;
1898                 public UniquePtr<Node> node;
1899                 public Operator op;
1900                 public Node* fromleft;
1901                 public Node* fromright;
1902             }
1903         }
1904 
1905         public class MultiplicativeExpressionRule : System.Text.Parsing.RuleParser
1906         {
1907             public MultiplicativeExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1908             {
1909                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1910                 SetValueTypeName(ToUtf32("Node*"));
1911                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1912                 AddLocalVariable(AttrOrVar(ToUtf32("Operator"), ToUtf32("op")));
1913             }
1914             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1915             {
1916                 parsingData->PushContext(Id(), new Context());
1917                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1918                 UniquePtr<Object> ctx_value = stack.Pop();
1919                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1920             }
1921             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1922             {
1923                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1924                 if (matched)
1925                 {
1926                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1927                 }
1928                 parsingData->PopContext(Id());
1929             }
1930             public override void Link()
1931             {
1932                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1933                 a0ActionParser->SetAction(A0Action);
1934                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1935                 a1ActionParser->SetAction(A1Action);
1936                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1937                 a2ActionParser->SetAction(A2Action);
1938                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1939                 a3ActionParser->SetAction(A3Action);
1940                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
1941                 a4ActionParser->SetAction(A4Action);
1942                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
1943                 a5ActionParser->SetAction(A5Action);
1944                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
1945                 a6ActionParser->SetAction(A6Action);
1946                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1947                 leftNonterminalParser->SetPre(Preleft);
1948                 leftNonterminalParser->SetPost(Postleft);
1949                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1950                 rightNonterminalParser->SetPre(Preright);
1951                 rightNonterminalParser->SetPost(Postright);
1952             }
1953             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1954             {
1955                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1956                 context->value = context->node.Release();
1957             }
1958             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1959             {
1960                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1961                 context->node.Reset(context->fromleft);
1962             }
1963             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1964             {
1965                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1966                 if (context->ctx->ParsingLvalueAndNotArguments()) pass = false;
1967             }
1968             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1969             {
1970                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1971                 context->op = Operator.mul;
1972             }
1973             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1974             {
1975                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1976                 context->op = Operator.div;
1977             }
1978             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1979             {
1980                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1981                 context->op = Operator.rem;
1982             }
1983             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1984             {
1985                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1986                 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, context->op));
1987             }
1988             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1989             {
1990                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1991                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1992             }
1993             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1994             {
1995                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1996                 if (matched)
1997                 {
1998                     UniquePtr<Object> fromleft_value = stack.Pop();
1999                     context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
2000                 }
2001             }
2002             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2003             {
2004                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2005                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2006             }
2007             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2008             {
2009                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2010                 if (matched)
2011                 {
2012                     UniquePtr<Object> fromright_value = stack.Pop();
2013                     context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
2014                 }
2015             }
2016             public class Context : System.Text.Parsing.Context
2017             {
2018                 public Context() : ctx(), value(), node(), op(), fromleft(), fromright()
2019                 {
2020                 }
2021                 public ParsingContext* ctx;
2022                 public Node* value;
2023                 public UniquePtr<Node> node;
2024                 public Operator op;
2025                 public Node* fromleft;
2026                 public Node* fromright;
2027             }
2028         }
2029 
2030         public class PMExpressionRule : System.Text.Parsing.RuleParser
2031         {
2032             public PMExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2033             {
2034                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2035                 SetValueTypeName(ToUtf32("Node*"));
2036                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
2037                 AddLocalVariable(AttrOrVar(ToUtf32("Operator"), ToUtf32("op")));
2038             }
2039             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2040             {
2041                 parsingData->PushContext(Id(), new Context());
2042                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2043                 UniquePtr<Object> ctx_value = stack.Pop();
2044                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2045             }
2046             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2047             {
2048                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2049                 if (matched)
2050                 {
2051                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
2052                 }
2053                 parsingData->PopContext(Id());
2054             }
2055             public override void Link()
2056             {
2057                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2058                 a0ActionParser->SetAction(A0Action);
2059                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2060                 a1ActionParser->SetAction(A1Action);
2061                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
2062                 a2ActionParser->SetAction(A2Action);
2063                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
2064                 a3ActionParser->SetAction(A3Action);
2065                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
2066                 a4ActionParser->SetAction(A4Action);
2067                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
2068                 leftNonterminalParser->SetPre(Preleft);
2069                 leftNonterminalParser->SetPost(Postleft);
2070                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
2071                 rightNonterminalParser->SetPre(Preright);
2072                 rightNonterminalParser->SetPost(Postright);
2073             }
2074             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2075             {
2076                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2077                 context->value = context->node.Release();
2078             }
2079             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2080             {
2081                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2082                 context->node.Reset(context->fromleft);
2083             }
2084             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2085             {
2086                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2087                 context->op = Operator.dotStar;
2088             }
2089             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2090             {
2091                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2092                 context->op = Operator.arrowStar;
2093             }
2094             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2095             {
2096                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2097                 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, context->op));
2098             }
2099             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2100             {
2101                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2102                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2103             }
2104             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2105             {
2106                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2107                 if (matched)
2108                 {
2109                     UniquePtr<Object> fromleft_value = stack.Pop();
2110                     context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
2111                 }
2112             }
2113             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2114             {
2115                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2116                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2117             }
2118             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2119             {
2120                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2121                 if (matched)
2122                 {
2123                     UniquePtr<Object> fromright_value = stack.Pop();
2124                     context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
2125                 }
2126             }
2127             public class Context : System.Text.Parsing.Context
2128             {
2129                 public Context() : ctx(), value(), node(), op(), fromleft(), fromright()
2130                 {
2131                 }
2132                 public ParsingContext* ctx;
2133                 public Node* value;
2134                 public UniquePtr<Node> node;
2135                 public Operator op;
2136                 public Node* fromleft;
2137                 public Node* fromright;
2138             }
2139         }
2140 
2141         public class CastExpressionRule : System.Text.Parsing.RuleParser
2142         {
2143             public CastExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2144             {
2145                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2146                 SetValueTypeName(ToUtf32("Node*"));
2147                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
2148             }
2149             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2150             {
2151                 parsingData->PushContext(Id(), new Context());
2152                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2153                 UniquePtr<Object> ctx_value = stack.Pop();
2154                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2155             }
2156             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2157             {
2158                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2159                 if (matched)
2160                 {
2161                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
2162                 }
2163                 parsingData->PopContext(Id());
2164             }
2165             public override void Link()
2166             {
2167                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2168                 a0ActionParser->SetAction(A0Action);
2169                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2170                 a1ActionParser->SetAction(A1Action);
2171                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
2172                 a2ActionParser->SetAction(A2Action);
2173                 NonterminalParser* typeExprNonterminalParser = GetNonterminal(ToUtf32("TypeExpr"));
2174                 typeExprNonterminalParser->SetPre(PreTypeExpr);
2175                 typeExprNonterminalParser->SetPost(PostTypeExpr);
2176                 NonterminalParser* castExpressionNonterminalParser = GetNonterminal(ToUtf32("CastExpression"));
2177                 castExpressionNonterminalParser->SetPre(PreCastExpression);
2178                 castExpressionNonterminalParser->SetPost(PostCastExpression);
2179                 NonterminalParser* unaryExpressionNonterminalParser = GetNonterminal(ToUtf32("UnaryExpression"));
2180                 unaryExpressionNonterminalParser->SetPre(PreUnaryExpression);
2181                 unaryExpressionNonterminalParser->SetPost(PostUnaryExpression);
2182             }
2183             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2184             {
2185                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2186                 context->value = context->node.Release();
2187             }
2188             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2189             {
2190                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2191                 context->node.Reset(new CastExpressionNode(span, context->fromTypeExpr, context->fromCastExpression));
2192             }
2193             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2194             {
2195                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2196                 context->node.Reset(context->fromUnaryExpression);
2197             }
2198             public void PreTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2199             {
2200                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2201                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2202             }
2203             public void PostTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2204             {
2205                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2206                 if (matched)
2207                 {
2208                     UniquePtr<Object> fromTypeExpr_value = stack.Pop();
2209                     context->fromTypeExpr = *cast<ValueObject<Node*>*>(fromTypeExpr_value.Get());
2210                 }
2211             }
2212             public void PreCastExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2213             {
2214                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2215                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2216             }
2217             public void PostCastExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2218             {
2219                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2220                 if (matched)
2221                 {
2222                     UniquePtr<Object> fromCastExpression_value = stack.Pop();
2223                     context->fromCastExpression = *cast<ValueObject<Node*>*>(fromCastExpression_value.Get());
2224                 }
2225             }
2226             public void PreUnaryExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2227             {
2228                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2229                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2230             }
2231             public void PostUnaryExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2232             {
2233                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2234                 if (matched)
2235                 {
2236                     UniquePtr<Object> fromUnaryExpression_value = stack.Pop();
2237                     context->fromUnaryExpression = *cast<ValueObject<Node*>*>(fromUnaryExpression_value.Get());
2238                 }
2239             }
2240             public class Context : System.Text.Parsing.Context
2241             {
2242                 public Context() : ctx(), value(), node(), fromTypeExpr(), fromCastExpression(), fromUnaryExpression()
2243                 {
2244                 }
2245                 public ParsingContext* ctx;
2246                 public Node* value;
2247                 public UniquePtr<Node> node;
2248                 public Node* fromTypeExpr;
2249                 public Node* fromCastExpression;
2250                 public Node* fromUnaryExpression;
2251             }
2252         }
2253 
2254         public class UnaryExpressionRule : System.Text.Parsing.RuleParser
2255         {
2256             public UnaryExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2257             {
2258                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2259                 SetValueTypeName(ToUtf32("Node*"));
2260             }
2261             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2262             {
2263                 parsingData->PushContext(Id(), new Context());
2264                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2265                 UniquePtr<Object> ctx_value = stack.Pop();
2266                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2267             }
2268             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2269             {
2270                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2271                 if (matched)
2272                 {
2273                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
2274                 }
2275                 parsingData->PopContext(Id());
2276             }
2277             public override void Link()
2278             {
2279                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2280                 a0ActionParser->SetAction(A0Action);
2281                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2282                 a1ActionParser->SetAction(A1Action);
2283                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
2284                 a2ActionParser->SetAction(A2Action);
2285                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
2286                 a3ActionParser->SetAction(A3Action);
2287                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
2288                 a4ActionParser->SetAction(A4Action);
2289                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
2290                 a5ActionParser->SetAction(A5Action);
2291                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
2292                 a6ActionParser->SetAction(A6Action);
2293                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
2294                 a7ActionParser->SetAction(A7Action);
2295                 NonterminalParser* c1NonterminalParser = GetNonterminal(ToUtf32("c1"));
2296                 c1NonterminalParser->SetPre(Prec1);
2297                 c1NonterminalParser->SetPost(Postc1);
2298                 NonterminalParser* c2NonterminalParser = GetNonterminal(ToUtf32("c2"));
2299                 c2NonterminalParser->SetPre(Prec2);
2300                 c2NonterminalParser->SetPost(Postc2);
2301                 NonterminalParser* opNonterminalParser = GetNonterminal(ToUtf32("op"));
2302                 opNonterminalParser->SetPost(Postop);
2303                 NonterminalParser* c3NonterminalParser = GetNonterminal(ToUtf32("c3"));
2304                 c3NonterminalParser->SetPre(Prec3);
2305                 c3NonterminalParser->SetPost(Postc3);
2306                 NonterminalParser* u4NonterminalParser = GetNonterminal(ToUtf32("u4"));
2307                 u4NonterminalParser->SetPre(Preu4);
2308                 u4NonterminalParser->SetPost(Postu4);
2309                 NonterminalParser* t5NonterminalParser = GetNonterminal(ToUtf32("t5"));
2310                 t5NonterminalParser->SetPre(Pret5);
2311                 t5NonterminalParser->SetPost(Postt5);
2312                 NonterminalParser* newExpressionNonterminalParser = GetNonterminal(ToUtf32("NewExpression"));
2313                 newExpressionNonterminalParser->SetPre(PreNewExpression);
2314                 newExpressionNonterminalParser->SetPost(PostNewExpression);
2315                 NonterminalParser* deleteExpressionNonterminalParser = GetNonterminal(ToUtf32("DeleteExpression"));
2316                 deleteExpressionNonterminalParser->SetPre(PreDeleteExpression);
2317                 deleteExpressionNonterminalParser->SetPost(PostDeleteExpression);
2318                 NonterminalParser* postfixExpressionNonterminalParser = GetNonterminal(ToUtf32("PostfixExpression"));
2319                 postfixExpressionNonterminalParser->SetPre(PrePostfixExpression);
2320                 postfixExpressionNonterminalParser->SetPost(PostPostfixExpression);
2321             }
2322             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2323             {
2324                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2325                 context->value = new PrefixIncrementNode(span, context->fromc1);
2326             }
2327             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2328             {
2329                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2330                 context->value = new PrefixDecrementNode(span, context->fromc2);
2331             }
2332             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2333             {
2334                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2335                 context->value = new UnaryExpressionNode(span, context->fromc3, context->fromop);
2336             }
2337             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2338             {
2339                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2340                 context->value = new SizeOfExpressionNode(span, context->fromu4);
2341             }
2342             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2343             {
2344                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2345                 context->value = new AlignOfExpressionNode(span, context->fromt5);
2346             }
2347             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2348             {
2349                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2350                 context->value = context->fromNewExpression;
2351             }
2352             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2353             {
2354                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2355                 context->value = context->fromDeleteExpression;
2356             }
2357             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2358             {
2359                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2360                 context->value = context->fromPostfixExpression;
2361             }
2362             public void Prec1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2363             {
2364                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2365                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2366             }
2367             public void Postc1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2368             {
2369                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2370                 if (matched)
2371                 {
2372                     UniquePtr<Object> fromc1_value = stack.Pop();
2373                     context->fromc1 = *cast<ValueObject<Node*>*>(fromc1_value.Get());
2374                 }
2375             }
2376             public void Prec2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2377             {
2378                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2379                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2380             }
2381             public void Postc2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2382             {
2383                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2384                 if (matched)
2385                 {
2386                     UniquePtr<Object> fromc2_value = stack.Pop();
2387                     context->fromc2 = *cast<ValueObject<Node*>*>(fromc2_value.Get());
2388                 }
2389             }
2390             public void Postop(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2391             {
2392                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2393                 if (matched)
2394                 {
2395                     UniquePtr<Object> fromop_value = stack.Pop();
2396                     context->fromop = *cast<ValueObject<Operator>*>(fromop_value.Get());
2397                 }
2398             }
2399             public void Prec3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2400             {
2401                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2402                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2403             }
2404             public void Postc3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2405             {
2406                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2407                 if (matched)
2408                 {
2409                     UniquePtr<Object> fromc3_value = stack.Pop();
2410                     context->fromc3 = *cast<ValueObject<Node*>*>(fromc3_value.Get());
2411                 }
2412             }
2413             public void Preu4(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2414             {
2415                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2416                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2417             }
2418             public void Postu4(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2419             {
2420                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2421                 if (matched)
2422                 {
2423                     UniquePtr<Object> fromu4_value = stack.Pop();
2424                     context->fromu4 = *cast<ValueObject<Node*>*>(fromu4_value.Get());
2425                 }
2426             }
2427             public void Pret5(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2428             {
2429                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2430                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2431             }
2432             public void Postt5(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2433             {
2434                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2435                 if (matched)
2436                 {
2437                     UniquePtr<Object> fromt5_value = stack.Pop();
2438                     context->fromt5 = *cast<ValueObject<Node*>*>(fromt5_value.Get());
2439                 }
2440             }
2441             public void PreNewExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2442             {
2443                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2444                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2445             }
2446             public void PostNewExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2447             {
2448                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2449                 if (matched)
2450                 {
2451                     UniquePtr<Object> fromNewExpression_value = stack.Pop();
2452                     context->fromNewExpression = *cast<ValueObject<NewExpressionNode*>*>(fromNewExpression_value.Get());
2453                 }
2454             }
2455             public void PreDeleteExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2456             {
2457                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2458                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2459             }
2460             public void PostDeleteExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2461             {
2462                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2463                 if (matched)
2464                 {
2465                     UniquePtr<Object> fromDeleteExpression_value = stack.Pop();
2466                     context->fromDeleteExpression = *cast<ValueObject<DeleteExpressionNode*>*>(fromDeleteExpression_value.Get());
2467                 }
2468             }
2469             public void PrePostfixExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2470             {
2471                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2472                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2473             }
2474             public void PostPostfixExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2475             {
2476                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2477                 if (matched)
2478                 {
2479                     UniquePtr<Object> fromPostfixExpression_value = stack.Pop();
2480                     context->fromPostfixExpression = *cast<ValueObject<Node*>*>(fromPostfixExpression_value.Get());
2481                 }
2482             }
2483             public class Context : System.Text.Parsing.Context
2484             {
2485                 public Context() : ctx(), value(), fromc1(), fromc2(), fromop(), fromc3(), fromu4(), fromt5(), fromNewExpression(), fromDeleteExpression(), fromPostfixExpression()
2486                 {
2487                 }
2488                 public ParsingContext* ctx;
2489                 public Node* value;
2490                 public Node* fromc1;
2491                 public Node* fromc2;
2492                 public Operator fromop;
2493                 public Node* fromc3;
2494                 public Node* fromu4;
2495                 public Node* fromt5;
2496                 public NewExpressionNode* fromNewExpression;
2497                 public DeleteExpressionNode* fromDeleteExpression;
2498                 public Node* fromPostfixExpression;
2499             }
2500         }
2501 
2502         public class UnaryOperatorRule : System.Text.Parsing.RuleParser
2503         {
2504             public UnaryOperatorRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2505             {
2506                 SetValueTypeName(ToUtf32("Operator"));
2507             }
2508             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2509             {
2510                 parsingData->PushContext(Id(), new Context());
2511                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2512             }
2513             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2514             {
2515                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2516                 if (matched)
2517                 {
2518                     stack.Push(UniquePtr<Object>(new ValueObject<Operator>(context->value)));
2519                 }
2520                 parsingData->PopContext(Id());
2521             }
2522             public override void Link()
2523             {
2524                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2525                 a0ActionParser->SetAction(A0Action);
2526                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2527                 a1ActionParser->SetAction(A1Action);
2528                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
2529                 a2ActionParser->SetAction(A2Action);
2530                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
2531                 a3ActionParser->SetAction(A3Action);
2532                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
2533                 a4ActionParser->SetAction(A4Action);
2534                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
2535                 a5ActionParser->SetAction(A5Action);
2536             }
2537             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2538             {
2539                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2540                 context->value = Operator.deref;
2541             }
2542             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2543             {
2544                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2545                 context->value = Operator.addrOf;
2546             }
2547             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2548             {
2549                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2550                 context->value = Operator.unaryPlus;
2551             }
2552             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2553             {
2554                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2555                 context->value = Operator.unaryMinus;
2556             }
2557             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2558             {
2559                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2560                 context->value = Operator.not_;
2561             }
2562             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2563             {
2564                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2565                 context->value = Operator.neg;
2566             }
2567             public class Context : System.Text.Parsing.Context
2568             {
2569                 public Context() : value()
2570                 {
2571                 }
2572                 public Operator value;
2573             }
2574         }
2575 
2576         public class NewExpressionRule : System.Text.Parsing.RuleParser
2577         {
2578             public NewExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2579             {
2580                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2581                 SetValueTypeName(ToUtf32("NewExpressionNode*"));
2582             }
2583             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2584             {
2585                 parsingData->PushContext(Id(), new Context());
2586                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2587                 UniquePtr<Object> ctx_value = stack.Pop();
2588                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2589             }
2590             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2591             {
2592                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2593                 if (matched)
2594                 {
2595                     stack.Push(UniquePtr<Object>(new ValueObject<NewExpressionNode*>(context->value)));
2596                 }
2597                 parsingData->PopContext(Id());
2598             }
2599             public override void Link()
2600             {
2601                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2602                 a0ActionParser->SetAction(A0Action);
2603                 NonterminalParser* newPlacementNonterminalParser = GetNonterminal(ToUtf32("NewPlacement"));
2604                 newPlacementNonterminalParser->SetPre(PreNewPlacement);
2605                 newPlacementNonterminalParser->SetPost(PostNewPlacement);
2606                 NonterminalParser* newTypeIdNonterminalParser = GetNonterminal(ToUtf32("NewTypeId"));
2607                 newTypeIdNonterminalParser->SetPre(PreNewTypeId);
2608                 newTypeIdNonterminalParser->SetPost(PostNewTypeId);
2609                 NonterminalParser* newInitializerNonterminalParser = GetNonterminal(ToUtf32("NewInitializer"));
2610                 newInitializerNonterminalParser->SetPre(PreNewInitializer);
2611                 newInitializerNonterminalParser->SetPost(PostNewInitializer);
2612             }
2613             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2614             {
2615                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2616                 context->value = new NewExpressionNode(span, context->fromNewPlacement, context->fromNewTypeId, context->fromNewInitializer);
2617             }
2618             public void PreNewPlacement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2619             {
2620                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2621                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2622             }
2623             public void PostNewPlacement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2624             {
2625                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2626                 if (matched)
2627                 {
2628                     UniquePtr<Object> fromNewPlacement_value = stack.Pop();
2629                     context->fromNewPlacement = *cast<ValueObject<ExpressionListNode*>*>(fromNewPlacement_value.Get());
2630                 }
2631             }
2632             public void PreNewTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2633             {
2634                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2635                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2636             }
2637             public void PostNewTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2638             {
2639                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2640                 if (matched)
2641                 {
2642                     UniquePtr<Object> fromNewTypeId_value = stack.Pop();
2643                     context->fromNewTypeId = *cast<ValueObject<Node*>*>(fromNewTypeId_value.Get());
2644                 }
2645             }
2646             public void PreNewInitializer(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2647             {
2648                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2649                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2650             }
2651             public void PostNewInitializer(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2652             {
2653                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2654                 if (matched)
2655                 {
2656                     UniquePtr<Object> fromNewInitializer_value = stack.Pop();
2657                     context->fromNewInitializer = *cast<ValueObject<ExpressionListNode*>*>(fromNewInitializer_value.Get());
2658                 }
2659             }
2660             public class Context : System.Text.Parsing.Context
2661             {
2662                 public Context() : ctx(), value(), fromNewPlacement(), fromNewTypeId(), fromNewInitializer()
2663                 {
2664                 }
2665                 public ParsingContext* ctx;
2666                 public NewExpressionNode* value;
2667                 public ExpressionListNode* fromNewPlacement;
2668                 public Node* fromNewTypeId;
2669                 public ExpressionListNode* fromNewInitializer;
2670             }
2671         }
2672 
2673         public class NewPlacementRule : System.Text.Parsing.RuleParser
2674         {
2675             public NewPlacementRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2676             {
2677                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2678                 SetValueTypeName(ToUtf32("ExpressionListNode*"));
2679             }
2680             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2681             {
2682                 parsingData->PushContext(Id(), new Context());
2683                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2684                 UniquePtr<Object> ctx_value = stack.Pop();
2685                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2686             }
2687             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2688             {
2689                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2690                 if (matched)
2691                 {
2692                     stack.Push(UniquePtr<Object>(new ValueObject<ExpressionListNode*>(context->value)));
2693                 }
2694                 parsingData->PopContext(Id());
2695             }
2696             public override void Link()
2697             {
2698                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2699                 a0ActionParser->SetAction(A0Action);
2700                 NonterminalParser* expressionListNonterminalParser = GetNonterminal(ToUtf32("ExpressionList"));
2701                 expressionListNonterminalParser->SetPre(PreExpressionList);
2702                 expressionListNonterminalParser->SetPost(PostExpressionList);
2703             }
2704             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2705             {
2706                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2707                 context->value = context->fromExpressionList;
2708             }
2709             public void PreExpressionList(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2710             {
2711                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2712                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2713             }
2714             public void PostExpressionList(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2715             {
2716                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2717                 if (matched)
2718                 {
2719                     UniquePtr<Object> fromExpressionList_value = stack.Pop();
2720                     context->fromExpressionList = *cast<ValueObject<ExpressionListNode*>*>(fromExpressionList_value.Get());
2721                 }
2722             }
2723             public class Context : System.Text.Parsing.Context
2724             {
2725                 public Context() : ctx(), value(), fromExpressionList()
2726                 {
2727                 }
2728                 public ParsingContext* ctx;
2729                 public ExpressionListNode* value;
2730                 public ExpressionListNode* fromExpressionList;
2731             }
2732         }
2733 
2734         public class NewTypeIdRule : System.Text.Parsing.RuleParser
2735         {
2736             public NewTypeIdRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2737             {
2738                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2739                 SetValueTypeName(ToUtf32("Node*"));
2740             }
2741             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2742             {
2743                 parsingData->PushContext(Id(), new Context());
2744                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2745                 UniquePtr<Object> ctx_value = stack.Pop();
2746                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2747             }
2748             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2749             {
2750                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2751                 if (matched)
2752                 {
2753                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
2754                 }
2755                 parsingData->PopContext(Id());
2756             }
2757             public override void Link()
2758             {
2759                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2760                 a0ActionParser->SetAction(A0Action);
2761                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2762                 a1ActionParser->SetAction(A1Action);
2763                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
2764                 typeNonterminalParser->SetPre(Pretype);
2765                 typeNonterminalParser->SetPost(Posttype);
2766                 NonterminalParser* sizeNonterminalParser = GetNonterminal(ToUtf32("size"));
2767                 sizeNonterminalParser->SetPre(Presize);
2768                 sizeNonterminalParser->SetPost(Postsize);
2769             }
2770             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2771             {
2772                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2773                 context->value = context->fromtype;
2774             }
2775             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2776             {
2777                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2778                 context->value = new ArrayTypeNode(span, context->fromtype, context->fromsize);
2779             }
2780             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2781             {
2782                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2783                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2784             }
2785             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2786             {
2787                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2788                 if (matched)
2789                 {
2790                     UniquePtr<Object> fromtype_value = stack.Pop();
2791                     context->fromtype = *cast<ValueObject<Node*>*>(fromtype_value.Get());
2792                 }
2793             }
2794             public void Presize(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2795             {
2796                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2797                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2798             }
2799             public void Postsize(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2800             {
2801                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2802                 if (matched)
2803                 {
2804                     UniquePtr<Object> fromsize_value = stack.Pop();
2805                     context->fromsize = *cast<ValueObject<Node*>*>(fromsize_value.Get());
2806                 }
2807             }
2808             public class Context : System.Text.Parsing.Context
2809             {
2810                 public Context() : ctx(), value(), fromtype(), fromsize()
2811                 {
2812                 }
2813                 public ParsingContext* ctx;
2814                 public Node* value;
2815                 public Node* fromtype;
2816                 public Node* fromsize;
2817             }
2818         }
2819 
2820         public class NewDeclaratorRule : System.Text.Parsing.RuleParser
2821         {
2822             public NewDeclaratorRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2823             {
2824                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2825                 SetValueTypeName(ToUtf32("Node*"));
2826             }
2827             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2828             {
2829                 parsingData->PushContext(Id(), new Context());
2830                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2831                 UniquePtr<Object> ctx_value = stack.Pop();
2832                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2833             }
2834             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2835             {
2836                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2837                 if (matched)
2838                 {
2839                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
2840                 }
2841                 parsingData->PopContext(Id());
2842             }
2843             public override void Link()
2844             {
2845                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2846                 a0ActionParser->SetAction(A0Action);
2847                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2848                 a1ActionParser->SetAction(A1Action);
2849                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
2850                 a2ActionParser->SetAction(A2Action);
2851                 a2ActionParser->SetFailure(A2ActionFail);
2852                 NonterminalParser* sizeNonterminalParser = GetNonterminal(ToUtf32("size"));
2853                 sizeNonterminalParser->SetPre(Presize);
2854                 sizeNonterminalParser->SetPost(Postsize);
2855             }
2856             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2857             {
2858                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2859                 context->ctx->BeginParsingArguments();
2860             }
2861             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2862             {
2863                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2864                 context->value = context->fromsize;
2865             }
2866             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2867             {
2868                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2869                 context->ctx->EndParsingArguments();
2870             }
2871             public void A2ActionFail(ParsingData* parsingData)
2872             {
2873                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2874                 context->ctx->EndParsingArguments();
2875             }
2876             public void Presize(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2877             {
2878                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2879                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2880             }
2881             public void Postsize(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2882             {
2883                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2884                 if (matched)
2885                 {
2886                     UniquePtr<Object> fromsize_value = stack.Pop();
2887                     context->fromsize = *cast<ValueObject<Node*>*>(fromsize_value.Get());
2888                 }
2889             }
2890             public class Context : System.Text.Parsing.Context
2891             {
2892                 public Context() : ctx(), value(), fromsize()
2893                 {
2894                 }
2895                 public ParsingContext* ctx;
2896                 public Node* value;
2897                 public Node* fromsize;
2898             }
2899         }
2900 
2901         public class NewInitializerRule : System.Text.Parsing.RuleParser
2902         {
2903             public NewInitializerRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2904             {
2905                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2906                 SetValueTypeName(ToUtf32("ExpressionListNode*"));
2907             }
2908             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2909             {
2910                 parsingData->PushContext(Id(), new Context());
2911                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2912                 UniquePtr<Object> ctx_value = stack.Pop();
2913                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2914             }
2915             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2916             {
2917                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2918                 if (matched)
2919                 {
2920                     stack.Push(UniquePtr<Object>(new ValueObject<ExpressionListNode*>(context->value)));
2921                 }
2922                 parsingData->PopContext(Id());
2923             }
2924             public override void Link()
2925             {
2926                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2927                 a0ActionParser->SetAction(A0Action);
2928                 NonterminalParser* argsNonterminalParser = GetNonterminal(ToUtf32("args"));
2929                 argsNonterminalParser->SetPre(Preargs);
2930                 argsNonterminalParser->SetPost(Postargs);
2931             }
2932             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2933             {
2934                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2935                 context->value = context->fromargs;
2936             }
2937             public void Preargs(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2938             {
2939                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2940                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2941             }
2942             public void Postargs(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2943             {
2944                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2945                 if (matched)
2946                 {
2947                     UniquePtr<Object> fromargs_value = stack.Pop();
2948                     context->fromargs = *cast<ValueObject<ExpressionListNode*>*>(fromargs_value.Get());
2949                 }
2950             }
2951             public class Context : System.Text.Parsing.Context
2952             {
2953                 public Context() : ctx(), value(), fromargs()
2954                 {
2955                 }
2956                 public ParsingContext* ctx;
2957                 public ExpressionListNode* value;
2958                 public ExpressionListNode* fromargs;
2959             }
2960         }
2961 
2962         public class DeleteExpressionRule : System.Text.Parsing.RuleParser
2963         {
2964             public DeleteExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2965             {
2966                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2967                 SetValueTypeName(ToUtf32("DeleteExpressionNode*"));
2968                 AddLocalVariable(AttrOrVar(ToUtf32("bool"), ToUtf32("arrayDelete")));
2969             }
2970             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2971             {
2972                 parsingData->PushContext(Id(), new Context());
2973                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2974                 UniquePtr<Object> ctx_value = stack.Pop();
2975                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2976             }
2977             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2978             {
2979                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2980                 if (matched)
2981                 {
2982                     stack.Push(UniquePtr<Object>(new ValueObject<DeleteExpressionNode*>(context->value)));
2983                 }
2984                 parsingData->PopContext(Id());
2985             }
2986             public override void Link()
2987             {
2988                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2989                 a0ActionParser->SetAction(A0Action);
2990                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2991                 a1ActionParser->SetAction(A1Action);
2992                 NonterminalParser* castExpressionNonterminalParser = GetNonterminal(ToUtf32("CastExpression"));
2993                 castExpressionNonterminalParser->SetPre(PreCastExpression);
2994                 castExpressionNonterminalParser->SetPost(PostCastExpression);
2995             }
2996             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2997             {
2998                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2999                 context->value = new DeleteExpressionNode(span, context->fromCastExpression, context->arrayDelete);
3000             }
3001             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3002             {
3003                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3004                 context->arrayDelete = true;
3005             }
3006             public void PreCastExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3007             {
3008                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3009                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3010             }
3011             public void PostCastExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3012             {
3013                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3014                 if (matched)
3015                 {
3016                     UniquePtr<Object> fromCastExpression_value = stack.Pop();
3017                     context->fromCastExpression = *cast<ValueObject<Node*>*>(fromCastExpression_value.Get());
3018                 }
3019             }
3020             public class Context : System.Text.Parsing.Context
3021             {
3022                 public Context() : ctx(), value(), arrayDelete(), fromCastExpression()
3023                 {
3024                 }
3025                 public ParsingContext* ctx;
3026                 public DeleteExpressionNode* value;
3027                 public bool arrayDelete;
3028                 public Node* fromCastExpression;
3029             }
3030         }
3031 
3032         public class PostfixExpressionRule : System.Text.Parsing.RuleParser
3033         {
3034             public PostfixExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3035             {
3036                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
3037                 SetValueTypeName(ToUtf32("Node*"));
3038                 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
3039             }
3040             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3041             {
3042                 parsingData->PushContext(Id(), new Context());
3043                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3044                 UniquePtr<Object> ctx_value = stack.Pop();
3045                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
3046             }
3047             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3048             {
3049                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3050                 if (matched)
3051                 {
3052                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
3053                 }
3054                 parsingData->PopContext(Id());
3055             }
3056             public override void Link()
3057             {
3058                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3059                 a0ActionParser->SetAction(A0Action);
3060                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
3061                 a1ActionParser->SetAction(A1Action);
3062                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
3063                 a2ActionParser->SetAction(A2Action);
3064                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
3065                 a3ActionParser->SetAction(A3Action);
3066                 a3ActionParser->SetFailure(A3ActionFail);
3067                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
3068                 a4ActionParser->SetAction(A4Action);
3069                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
3070                 a5ActionParser->SetAction(A5Action);
3071                 a5ActionParser->SetFailure(A5ActionFail);
3072                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
3073                 a6ActionParser->SetAction(A6Action);
3074                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
3075                 a7ActionParser->SetAction(A7Action);
3076                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
3077                 a8ActionParser->SetAction(A8Action);
3078                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
3079                 a9ActionParser->SetAction(A9Action);
3080                 NonterminalParser* primaryExpressionNonterminalParser = GetNonterminal(ToUtf32("PrimaryExpression"));
3081                 primaryExpressionNonterminalParser->SetPre(PrePrimaryExpression);
3082                 primaryExpressionNonterminalParser->SetPost(PostPrimaryExpression);
3083                 NonterminalParser* subscriptNonterminalParser = GetNonterminal(ToUtf32("subscript"));
3084                 subscriptNonterminalParser->SetPre(Presubscript);
3085                 subscriptNonterminalParser->SetPost(Postsubscript);
3086                 NonterminalParser* argumentsNonterminalParser = GetNonterminal(ToUtf32("arguments"));
3087                 argumentsNonterminalParser->SetPre(Prearguments);
3088                 argumentsNonterminalParser->SetPost(Postarguments);
3089                 NonterminalParser* id1NonterminalParser = GetNonterminal(ToUtf32("id1"));
3090                 id1NonterminalParser->SetPre(Preid1);
3091                 id1NonterminalParser->SetPost(Postid1);
3092                 NonterminalParser* id2NonterminalParser = GetNonterminal(ToUtf32("id2"));
3093                 id2NonterminalParser->SetPre(Preid2);
3094                 id2NonterminalParser->SetPost(Postid2);
3095             }
3096             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3097             {
3098                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3099                 context->value = context->node.Release();
3100             }
3101             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3102             {
3103                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3104                 context->node.Reset(context->fromPrimaryExpression);
3105             }
3106             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3107             {
3108                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3109                 context->ctx->BeginParsingArguments();
3110             }
3111             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3112             {
3113                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3114                 context->node.Reset(new SubscriptExpressionNode(span, context->node.Release(), context->fromsubscript));
3115                 context->ctx->EndParsingArguments();
3116             }
3117             public void A3ActionFail(ParsingData* parsingData)
3118             {
3119                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3120                 context->ctx->EndParsingArguments();
3121             }
3122             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3123             {
3124                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3125                 context->ctx->BeginParsingArguments();
3126             }
3127             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3128             {
3129                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3130                 context->node.Reset(new InvokeExpressionNode(span, context->node.Release(), context->fromarguments));
3131                 context->ctx->EndParsingArguments();
3132             }
3133             public void A5ActionFail(ParsingData* parsingData)
3134             {
3135                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3136                 context->ctx->EndParsingArguments();
3137             }
3138             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3139             {
3140                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3141                 context->node.Reset(new DotNode(span, context->node.Release(), context->fromid1));
3142             }
3143             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3144             {
3145                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3146                 context->node.Reset(new ArrowNode(span, context->node.Release(), context->fromid2));
3147             }
3148             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3149             {
3150                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3151                 context->node.Reset(new PostfixIncrementNode(span, context->node.Release()));
3152             }
3153             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3154             {
3155                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3156                 context->node.Reset(new PostfixDecrementNode(span, context->node.Release()));
3157             }
3158             public void PrePrimaryExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3159             {
3160                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3161                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3162             }
3163             public void PostPrimaryExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3164             {
3165                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3166                 if (matched)
3167                 {
3168                     UniquePtr<Object> fromPrimaryExpression_value = stack.Pop();
3169                     context->fromPrimaryExpression = *cast<ValueObject<Node*>*>(fromPrimaryExpression_value.Get());
3170                 }
3171             }
3172             public void Presubscript(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3173             {
3174                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3175                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3176             }
3177             public void Postsubscript(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3178             {
3179                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3180                 if (matched)
3181                 {
3182                     UniquePtr<Object> fromsubscript_value = stack.Pop();
3183                     context->fromsubscript = *cast<ValueObject<Node*>*>(fromsubscript_value.Get());
3184                 }
3185             }
3186             public void Prearguments(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3187             {
3188                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3189                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3190             }
3191             public void Postarguments(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3192             {
3193                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3194                 if (matched)
3195                 {
3196                     UniquePtr<Object> fromarguments_value = stack.Pop();
3197                     context->fromarguments = *cast<ValueObject<ExpressionListNode*>*>(fromarguments_value.Get());
3198                 }
3199             }
3200             public void Preid1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3201             {
3202                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3203                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3204             }
3205             public void Postid1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3206             {
3207                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3208                 if (matched)
3209                 {
3210                     UniquePtr<Object> fromid1_value = stack.Pop();
3211                     context->fromid1 = *cast<ValueObject<Node*>*>(fromid1_value.Get());
3212                 }
3213             }
3214             public void Preid2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3215             {
3216                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3217                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3218             }
3219             public void Postid2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3220             {
3221                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3222                 if (matched)
3223                 {
3224                     UniquePtr<Object> fromid2_value = stack.Pop();
3225                     context->fromid2 = *cast<ValueObject<Node*>*>(fromid2_value.Get());
3226                 }
3227             }
3228             public class Context : System.Text.Parsing.Context
3229             {
3230                 public Context() : ctx(), value(), node(), fromPrimaryExpression(), fromsubscript(), fromarguments(), fromid1(), fromid2()
3231                 {
3232                 }
3233                 public ParsingContext* ctx;
3234                 public Node* value;
3235                 public UniquePtr<Node> node;
3236                 public Node* fromPrimaryExpression;
3237                 public Node* fromsubscript;
3238                 public ExpressionListNode* fromarguments;
3239                 public Node* fromid1;
3240                 public Node* fromid2;
3241             }
3242         }
3243 
3244         public class PrimaryExpressionRule : System.Text.Parsing.RuleParser
3245         {
3246             public PrimaryExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3247             {
3248                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
3249                 SetValueTypeName(ToUtf32("Node*"));
3250             }
3251             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3252             {
3253                 parsingData->PushContext(Id(), new Context());
3254                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3255                 UniquePtr<Object> ctx_value = stack.Pop();
3256                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
3257             }
3258             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3259             {
3260                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3261                 if (matched)
3262                 {
3263                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
3264                 }
3265                 parsingData->PopContext(Id());
3266             }
3267             public override void Link()
3268             {
3269                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3270                 a0ActionParser->SetAction(A0Action);
3271                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
3272                 a1ActionParser->SetAction(A1Action);
3273                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
3274                 a2ActionParser->SetAction(A2Action);
3275                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
3276                 a3ActionParser->SetAction(A3Action);
3277                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
3278                 a4ActionParser->SetAction(A4Action);
3279                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
3280                 a5ActionParser->SetAction(A5Action);
3281                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
3282                 a6ActionParser->SetAction(A6Action);
3283                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
3284                 a7ActionParser->SetAction(A7Action);
3285                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
3286                 a8ActionParser->SetAction(A8Action);
3287                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
3288                 a9ActionParser->SetAction(A9Action);
3289                 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
3290                 a10ActionParser->SetAction(A10Action);
3291                 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
3292                 a11ActionParser->SetAction(A11Action);
3293                 ActionParser* a12ActionParser = GetAction(ToUtf32("A12"));
3294                 a12ActionParser->SetAction(A12Action);
3295                 NonterminalParser* literalNonterminalParser = GetNonterminal(ToUtf32("Literal"));
3296                 literalNonterminalParser->SetPost(PostLiteral);
3297                 NonterminalParser* definedExprNonterminalParser = GetNonterminal(ToUtf32("DefinedExpr"));
3298                 definedExprNonterminalParser->SetPost(PostDefinedExpr);
3299                 NonterminalParser* exprNonterminalParser = GetNonterminal(ToUtf32("expr"));
3300                 exprNonterminalParser->SetPre(Preexpr);
3301                 exprNonterminalParser->SetPost(Postexpr);
3302                 NonterminalParser* cppCastExpressionNonterminalParser = GetNonterminal(ToUtf32("CppCastExpression"));
3303                 cppCastExpressionNonterminalParser->SetPre(PreCppCastExpression);
3304                 cppCastExpressionNonterminalParser->SetPost(PostCppCastExpression);
3305                 NonterminalParser* typeIdExpressionNonterminalParser = GetNonterminal(ToUtf32("TypeIdExpression"));
3306                 typeIdExpressionNonterminalParser->SetPre(PreTypeIdExpression);
3307                 typeIdExpressionNonterminalParser->SetPost(PostTypeIdExpression);
3308                 NonterminalParser* s1NonterminalParser = GetNonterminal(ToUtf32("s1"));
3309                 s1NonterminalParser->SetPost(Posts1);
3310                 NonterminalParser* args1NonterminalParser = GetNonterminal(ToUtf32("args1"));
3311                 args1NonterminalParser->SetPre(Preargs1);
3312                 args1NonterminalParser->SetPost(Postargs1);
3313                 NonterminalParser* s2NonterminalParser = GetNonterminal(ToUtf32("s2"));
3314                 s2NonterminalParser->SetPost(Posts2);
3315                 NonterminalParser* b1NonterminalParser = GetNonterminal(ToUtf32("b1"));
3316                 b1NonterminalParser->SetPre(Preb1);
3317                 b1NonterminalParser->SetPost(Postb1);
3318                 NonterminalParser* t1NonterminalParser = GetNonterminal(ToUtf32("t1"));
3319                 t1NonterminalParser->SetPre(Pret1);
3320                 t1NonterminalParser->SetPost(Postt1);
3321                 NonterminalParser* args2NonterminalParser = GetNonterminal(ToUtf32("args2"));
3322                 args2NonterminalParser->SetPre(Preargs2);
3323                 args2NonterminalParser->SetPost(Postargs2);
3324                 NonterminalParser* t2NonterminalParser = GetNonterminal(ToUtf32("t2"));
3325                 t2NonterminalParser->SetPre(Pret2);
3326                 t2NonterminalParser->SetPost(Postt2);
3327                 NonterminalParser* b2NonterminalParser = GetNonterminal(ToUtf32("b2"));
3328                 b2NonterminalParser->SetPre(Preb2);
3329                 b2NonterminalParser->SetPost(Postb2);
3330                 NonterminalParser* idExpressionNonterminalParser = GetNonterminal(ToUtf32("IdExpression"));
3331                 idExpressionNonterminalParser->SetPre(PreIdExpression);
3332                 idExpressionNonterminalParser->SetPost(PostIdExpression);
3333                 NonterminalParser* lambdaExpressionNonterminalParser = GetNonterminal(ToUtf32("LambdaExpression"));
3334                 lambdaExpressionNonterminalParser->SetPre(PreLambdaExpression);
3335                 lambdaExpressionNonterminalParser->SetPost(PostLambdaExpression);
3336             }
3337             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3338             {
3339                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3340                 context->value = context->fromLiteral;
3341             }
3342             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3343             {
3344                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3345                 context->value = new ThisNode(span);
3346             }
3347             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3348             {
3349                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3350                 pass = context->ctx->AcceptDefined();
3351             }
3352             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3353             {
3354                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3355                 context->value = context->fromDefinedExpr;
3356             }
3357             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3358             {
3359                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3360                 context->value = new ParenthesizedExpressionNode(span, context->fromexpr);
3361             }
3362             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3363             {
3364                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3365                 context->value = context->fromCppCastExpression;
3366             }
3367             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3368             {
3369                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3370                 context->value = context->fromTypeIdExpression;
3371             }
3372             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3373             {
3374                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3375                 context->value = new InvokeExpressionNode(span, new SimpleTypeNode(span, context->froms1), context->fromargs1);
3376             }
3377             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3378             {
3379                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3380                 context->value = new InvokeExpressionNode(span, new SimpleTypeNode(span, context->froms2), context->fromb1);
3381             }
3382             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3383             {
3384                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3385                 context->value = new InvokeExpressionNode(span, context->fromt1, context->fromargs2);
3386             }
3387             public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3388             {
3389                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3390                 context->value = new InvokeExpressionNode(span, context->fromt2, context->fromb2);
3391             }
3392             public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3393             {
3394                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3395                 context->value = context->fromIdExpression;
3396             }
3397             public void A12Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3398             {
3399                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3400                 context->value = context->fromLambdaExpression;
3401             }
3402             public void PostLiteral(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3403             {
3404                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3405                 if (matched)
3406                 {
3407                     UniquePtr<Object> fromLiteral_value = stack.Pop();
3408                     context->fromLiteral = *cast<ValueObject<LiteralNode*>*>(fromLiteral_value.Get());
3409                 }
3410             }
3411             public void PostDefinedExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3412             {
3413                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3414                 if (matched)
3415                 {
3416                     UniquePtr<Object> fromDefinedExpr_value = stack.Pop();
3417                     context->fromDefinedExpr = *cast<ValueObject<Node*>*>(fromDefinedExpr_value.Get());
3418                 }
3419             }
3420             public void Preexpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3421             {
3422                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3423                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3424             }
3425             public void Postexpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3426             {
3427                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3428                 if (matched)
3429                 {
3430                     UniquePtr<Object> fromexpr_value = stack.Pop();
3431                     context->fromexpr = *cast<ValueObject<Node*>*>(fromexpr_value.Get());
3432                 }
3433             }
3434             public void PreCppCastExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3435             {
3436                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3437                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3438             }
3439             public void PostCppCastExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3440             {
3441                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3442                 if (matched)
3443                 {
3444                     UniquePtr<Object> fromCppCastExpression_value = stack.Pop();
3445                     context->fromCppCastExpression = *cast<ValueObject<Node*>*>(fromCppCastExpression_value.Get());
3446                 }
3447             }
3448             public void PreTypeIdExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3449             {
3450                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3451                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3452             }
3453             public void PostTypeIdExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3454             {
3455                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3456                 if (matched)
3457                 {
3458                     UniquePtr<Object> fromTypeIdExpression_value = stack.Pop();
3459                     context->fromTypeIdExpression = *cast<ValueObject<Node*>*>(fromTypeIdExpression_value.Get());
3460                 }
3461             }
3462             public void Posts1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3463             {
3464                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3465                 if (matched)
3466                 {
3467                     UniquePtr<Object> froms1_value = stack.Pop();
3468                     context->froms1 = *cast<ValueObject<SimpleTypeSpecifiers>*>(froms1_value.Get());
3469                 }
3470             }
3471             public void Preargs1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3472             {
3473                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3474                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3475             }
3476             public void Postargs1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3477             {
3478                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3479                 if (matched)
3480                 {
3481                     UniquePtr<Object> fromargs1_value = stack.Pop();
3482                     context->fromargs1 = *cast<ValueObject<ExpressionListNode*>*>(fromargs1_value.Get());
3483                 }
3484             }
3485             public void Posts2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3486             {
3487                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3488                 if (matched)
3489                 {
3490                     UniquePtr<Object> froms2_value = stack.Pop();
3491                     context->froms2 = *cast<ValueObject<SimpleTypeSpecifiers>*>(froms2_value.Get());
3492                 }
3493             }
3494             public void Preb1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3495             {
3496                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3497                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3498             }
3499             public void Postb1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3500             {
3501                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3502                 if (matched)
3503                 {
3504                     UniquePtr<Object> fromb1_value = stack.Pop();
3505                     context->fromb1 = *cast<ValueObject<BracedInitializerListNode*>*>(fromb1_value.Get());
3506                 }
3507             }
3508             public void Pret1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3509             {
3510                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3511                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3512             }
3513             public void Postt1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3514             {
3515                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3516                 if (matched)
3517                 {
3518                     UniquePtr<Object> fromt1_value = stack.Pop();
3519                     context->fromt1 = *cast<ValueObject<Node*>*>(fromt1_value.Get());
3520                 }
3521             }
3522             public void Preargs2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3523             {
3524                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3525                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3526             }
3527             public void Postargs2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3528             {
3529                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3530                 if (matched)
3531                 {
3532                     UniquePtr<Object> fromargs2_value = stack.Pop();
3533                     context->fromargs2 = *cast<ValueObject<ExpressionListNode*>*>(fromargs2_value.Get());
3534                 }
3535             }
3536             public void Pret2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3537             {
3538                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3539                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3540             }
3541             public void Postt2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3542             {
3543                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3544                 if (matched)
3545                 {
3546                     UniquePtr<Object> fromt2_value = stack.Pop();
3547                     context->fromt2 = *cast<ValueObject<Node*>*>(fromt2_value.Get());
3548                 }
3549             }
3550             public void Preb2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3551             {
3552                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3553                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3554             }
3555             public void Postb2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3556             {
3557                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3558                 if (matched)
3559                 {
3560                     UniquePtr<Object> fromb2_value = stack.Pop();
3561                     context->fromb2 = *cast<ValueObject<BracedInitializerListNode*>*>(fromb2_value.Get());
3562                 }
3563             }
3564             public void PreIdExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3565             {
3566                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3567                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3568             }
3569             public void PostIdExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3570             {
3571                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3572                 if (matched)
3573                 {
3574                     UniquePtr<Object> fromIdExpression_value = stack.Pop();
3575                     context->fromIdExpression = *cast<ValueObject<Node*>*>(fromIdExpression_value.Get());
3576                 }
3577             }
3578             public void PreLambdaExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3579             {
3580                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3581                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3582             }
3583             public void PostLambdaExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3584             {
3585                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3586                 if (matched)
3587                 {
3588                     UniquePtr<Object> fromLambdaExpression_value = stack.Pop();
3589                     context->fromLambdaExpression = *cast<ValueObject<LambdaExpressionNode*>*>(fromLambdaExpression_value.Get());
3590                 }
3591             }
3592             public class Context : System.Text.Parsing.Context
3593             {
3594                 public Context() : ctx(), value(), fromLiteral(), fromDefinedExpr(), fromexpr(), fromCppCastExpression(), fromTypeIdExpression(), froms1(), fromargs1(), froms2(), fromb1(), fromt1(), fromargs2(), fromt2(), fromb2(), fromIdExpression(), fromLambdaExpression()
3595                 {
3596                 }
3597                 public ParsingContext* ctx;
3598                 public Node* value;
3599                 public LiteralNode* fromLiteral;
3600                 public Node* fromDefinedExpr;
3601                 public Node* fromexpr;
3602                 public Node* fromCppCastExpression;
3603                 public Node* fromTypeIdExpression;
3604                 public SimpleTypeSpecifiers froms1;
3605                 public ExpressionListNode* fromargs1;
3606                 public SimpleTypeSpecifiers froms2;
3607                 public BracedInitializerListNode* fromb1;
3608                 public Node* fromt1;
3609                 public ExpressionListNode* fromargs2;
3610                 public Node* fromt2;
3611                 public BracedInitializerListNode* fromb2;
3612                 public Node* fromIdExpression;
3613                 public LambdaExpressionNode* fromLambdaExpression;
3614             }
3615         }
3616 
3617         public class CppCastExpressionRule : System.Text.Parsing.RuleParser
3618         {
3619             public CppCastExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3620             {
3621                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
3622                 SetValueTypeName(ToUtf32("Node*"));
3623                 AddLocalVariable(AttrOrVar(ToUtf32("CppCast"), ToUtf32("cast_")));
3624             }
3625             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3626             {
3627                 parsingData->PushContext(Id(), new Context());
3628                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3629                 UniquePtr<Object> ctx_value = stack.Pop();
3630                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
3631             }
3632             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3633             {
3634                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3635                 if (matched)
3636                 {
3637                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
3638                 }
3639                 parsingData->PopContext(Id());
3640             }
3641             public override void Link()
3642             {
3643                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3644                 a0ActionParser->SetAction(A0Action);
3645                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
3646                 a1ActionParser->SetAction(A1Action);
3647                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
3648                 a2ActionParser->SetAction(A2Action);
3649                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
3650                 a3ActionParser->SetAction(A3Action);
3651                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
3652                 a4ActionParser->SetAction(A4Action);
3653                 NonterminalParser* t1NonterminalParser = GetNonterminal(ToUtf32("t1"));
3654                 t1NonterminalParser->SetPre(Pret1);
3655                 t1NonterminalParser->SetPost(Postt1);
3656                 NonterminalParser* e1NonterminalParser = GetNonterminal(ToUtf32("e1"));
3657                 e1NonterminalParser->SetPre(Pree1);
3658                 e1NonterminalParser->SetPost(Poste1);
3659             }
3660             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3661             {
3662                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3663                 context->value = new CppCastNode(span, context->cast_, context->fromt1, context->frome1);
3664             }
3665             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3666             {
3667                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3668                 context->cast_ = CppCast.dynamicCast;
3669             }
3670             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3671             {
3672                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3673                 context->cast_ = CppCast.staticCast;
3674             }
3675             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3676             {
3677                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3678                 context->cast_ = CppCast.reinterpretCast;
3679             }
3680             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3681             {
3682                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3683                 context->cast_ = CppCast.constCast;
3684             }
3685             public void Pret1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3686             {
3687                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3688                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3689             }
3690             public void Postt1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3691             {
3692                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3693                 if (matched)
3694                 {
3695                     UniquePtr<Object> fromt1_value = stack.Pop();
3696                     context->fromt1 = *cast<ValueObject<Node*>*>(fromt1_value.Get());
3697                 }
3698             }
3699             public void Pree1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3700             {
3701                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3702                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3703             }
3704             public void Poste1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3705             {
3706                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3707                 if (matched)
3708                 {
3709                     UniquePtr<Object> frome1_value = stack.Pop();
3710                     context->frome1 = *cast<ValueObject<Node*>*>(frome1_value.Get());
3711                 }
3712             }
3713             public class Context : System.Text.Parsing.Context
3714             {
3715                 public Context() : ctx(), value(), cast_(), fromt1(), frome1()
3716                 {
3717                 }
3718                 public ParsingContext* ctx;
3719                 public Node* value;
3720                 public CppCast cast_;
3721                 public Node* fromt1;
3722                 public Node* frome1;
3723             }
3724         }
3725 
3726         public class DefinedExprRule : System.Text.Parsing.RuleParser
3727         {
3728             public DefinedExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3729             {
3730                 SetValueTypeName(ToUtf32("Node*"));
3731             }
3732             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3733             {
3734                 parsingData->PushContext(Id(), new Context());
3735                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3736             }
3737             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3738             {
3739                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3740                 if (matched)
3741                 {
3742                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
3743                 }
3744                 parsingData->PopContext(Id());
3745             }
3746             public override void Link()
3747             {
3748                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3749                 a0ActionParser->SetAction(A0Action);
3750                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
3751                 a1ActionParser->SetAction(A1Action);
3752                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
3753                 a2ActionParser->SetAction(A2Action);
3754                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
3755                 a3ActionParser->SetAction(A3Action);
3756                 NonterminalParser* id1NonterminalParser = GetNonterminal(ToUtf32("id1"));
3757                 id1NonterminalParser->SetPost(Postid1);
3758                 NonterminalParser* id2NonterminalParser = GetNonterminal(ToUtf32("id2"));
3759                 id2NonterminalParser->SetPost(Postid2);
3760                 NonterminalParser* lit1NonterminalParser = GetNonterminal(ToUtf32("lit1"));
3761                 lit1NonterminalParser->SetPost(Postlit1);
3762                 NonterminalParser* lit2NonterminalParser = GetNonterminal(ToUtf32("lit2"));
3763                 lit2NonterminalParser->SetPost(Postlit2);
3764             }
3765             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3766             {
3767                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3768                 context->value = new DefinedNode(span, context->fromid1);
3769             }
3770             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3771             {
3772                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3773                 context->value = new DefinedNode(span, context->fromid2);
3774             }
3775             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3776             {
3777                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3778                 context->value = new BooleanLiteralNode(span, true);
3779             }
3780             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3781             {
3782                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3783                 context->value = new BooleanLiteralNode(span, true);
3784             }
3785             public void Postid1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3786             {
3787                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3788                 if (matched)
3789                 {
3790                     UniquePtr<Object> fromid1_value = stack.Pop();
3791                     context->fromid1 = *cast<ValueObject<ustring>*>(fromid1_value.Get());
3792                 }
3793             }
3794             public void Postid2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3795             {
3796                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3797                 if (matched)
3798                 {
3799                     UniquePtr<Object> fromid2_value = stack.Pop();
3800                     context->fromid2 = *cast<ValueObject<ustring>*>(fromid2_value.Get());
3801                 }
3802             }
3803             public void Postlit1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3804             {
3805                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3806                 if (matched)
3807                 {
3808                     UniquePtr<Object> fromlit1_value = stack.Pop();
3809                     context->fromlit1 = *cast<ValueObject<LiteralNode*>*>(fromlit1_value.Get());
3810                 }
3811             }
3812             public void Postlit2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3813             {
3814                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3815                 if (matched)
3816                 {
3817                     UniquePtr<Object> fromlit2_value = stack.Pop();
3818                     context->fromlit2 = *cast<ValueObject<LiteralNode*>*>(fromlit2_value.Get());
3819                 }
3820             }
3821             public class Context : System.Text.Parsing.Context
3822             {
3823                 public Context() : value(), fromid1(), fromid2(), fromlit1(), fromlit2()
3824                 {
3825                 }
3826                 public Node* value;
3827                 public ustring fromid1;
3828                 public ustring fromid2;
3829                 public LiteralNode* fromlit1;
3830                 public LiteralNode* fromlit2;
3831             }
3832         }
3833 
3834         public class TypeIdExpressionRule : System.Text.Parsing.RuleParser
3835         {
3836             public TypeIdExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3837             {
3838                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
3839                 SetValueTypeName(ToUtf32("Node*"));
3840             }
3841             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3842             {
3843                 parsingData->PushContext(Id(), new Context());
3844                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3845                 UniquePtr<Object> ctx_value = stack.Pop();
3846                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
3847             }
3848             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3849             {
3850                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3851                 if (matched)
3852                 {
3853                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
3854                 }
3855                 parsingData->PopContext(Id());
3856             }
3857             public override void Link()
3858             {
3859                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3860                 a0ActionParser->SetAction(A0Action);
3861                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
3862                 a1ActionParser->SetAction(A1Action);
3863                 NonterminalParser* t1NonterminalParser = GetNonterminal(ToUtf32("t1"));
3864                 t1NonterminalParser->SetPre(Pret1);
3865                 t1NonterminalParser->SetPost(Postt1);
3866                 NonterminalParser* e1NonterminalParser = GetNonterminal(ToUtf32("e1"));
3867                 e1NonterminalParser->SetPre(Pree1);
3868                 e1NonterminalParser->SetPost(Poste1);
3869             }
3870             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3871             {
3872                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3873                 context->value = new TypeIdNode(span, context->fromt1);
3874             }
3875             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3876             {
3877                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3878                 context->value = new TypeIdNode(span, context->frome1);
3879             }
3880             public void Pret1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3881             {
3882                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3883                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3884             }
3885             public void Postt1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3886             {
3887                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3888                 if (matched)
3889                 {
3890                     UniquePtr<Object> fromt1_value = stack.Pop();
3891                     context->fromt1 = *cast<ValueObject<Node*>*>(fromt1_value.Get());
3892                 }
3893             }
3894             public void Pree1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3895             {
3896                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3897                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3898             }
3899             public void Poste1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3900             {
3901                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3902                 if (matched)
3903                 {
3904                     UniquePtr<Object> frome1_value = stack.Pop();
3905                     context->frome1 = *cast<ValueObject<Node*>*>(frome1_value.Get());
3906                 }
3907             }
3908             public class Context : System.Text.Parsing.Context
3909             {
3910                 public Context() : ctx(), value(), fromt1(), frome1()
3911                 {
3912                 }
3913                 public ParsingContext* ctx;
3914                 public Node* value;
3915                 public Node* fromt1;
3916                 public Node* frome1;
3917             }
3918         }
3919 
3920         public class IdExpressionRule : System.Text.Parsing.RuleParser
3921         {
3922             public IdExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3923             {
3924                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
3925                 SetValueTypeName(ToUtf32("Node*"));
3926             }
3927             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3928             {
3929                 parsingData->PushContext(Id(), new Context());
3930                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3931                 UniquePtr<Object> ctx_value = stack.Pop();
3932                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
3933             }
3934             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3935             {
3936                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3937                 if (matched)
3938                 {
3939                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
3940                 }
3941                 parsingData->PopContext(Id());
3942             }
3943             public override void Link()
3944             {
3945                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3946                 a0ActionParser->SetAction(A0Action);
3947                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
3948                 a1ActionParser->SetAction(A1Action);
3949                 NonterminalParser* qualifiedIdExprNonterminalParser = GetNonterminal(ToUtf32("QualifiedIdExpr"));
3950                 qualifiedIdExprNonterminalParser->SetPre(PreQualifiedIdExpr);
3951                 qualifiedIdExprNonterminalParser->SetPost(PostQualifiedIdExpr);
3952                 NonterminalParser* unqualifiedIdExprNonterminalParser = GetNonterminal(ToUtf32("UnqualifiedIdExpr"));
3953                 unqualifiedIdExprNonterminalParser->SetPre(PreUnqualifiedIdExpr);
3954                 unqualifiedIdExprNonterminalParser->SetPost(PostUnqualifiedIdExpr);
3955             }
3956             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3957             {
3958                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3959                 context->value = context->fromQualifiedIdExpr;
3960             }
3961             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3962             {
3963                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3964                 context->value = context->fromUnqualifiedIdExpr;
3965             }
3966             public void PreQualifiedIdExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3967             {
3968                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3969                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3970             }
3971             public void PostQualifiedIdExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3972             {
3973                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3974                 if (matched)
3975                 {
3976                     UniquePtr<Object> fromQualifiedIdExpr_value = stack.Pop();
3977                     context->fromQualifiedIdExpr = *cast<ValueObject<Node*>*>(fromQualifiedIdExpr_value.Get());
3978                 }
3979             }
3980             public void PreUnqualifiedIdExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3981             {
3982                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3983                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3984             }
3985             public void PostUnqualifiedIdExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3986             {
3987                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3988                 if (matched)
3989                 {
3990                     UniquePtr<Object> fromUnqualifiedIdExpr_value = stack.Pop();
3991                     context->fromUnqualifiedIdExpr = *cast<ValueObject<Node*>*>(fromUnqualifiedIdExpr_value.Get());
3992                 }
3993             }
3994             public class Context : System.Text.Parsing.Context
3995             {
3996                 public Context() : ctx(), value(), fromQualifiedIdExpr(), fromUnqualifiedIdExpr()
3997                 {
3998                 }
3999                 public ParsingContext* ctx;
4000                 public Node* value;
4001                 public Node* fromQualifiedIdExpr;
4002                 public Node* fromUnqualifiedIdExpr;
4003             }
4004         }
4005 
4006         public class UnqualifiedIdExprRule : System.Text.Parsing.RuleParser
4007         {
4008             public UnqualifiedIdExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4009             {
4010                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
4011                 SetValueTypeName(ToUtf32("Node*"));
4012             }
4013             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4014             {
4015                 parsingData->PushContext(Id(), new Context());
4016                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4017                 UniquePtr<Object> ctx_value = stack.Pop();
4018                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
4019             }
4020             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4021             {
4022                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4023                 if (matched)
4024                 {
4025                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
4026                 }
4027                 parsingData->PopContext(Id());
4028             }
4029             public override void Link()
4030             {
4031                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4032                 a0ActionParser->SetAction(A0Action);
4033                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
4034                 a1ActionParser->SetAction(A1Action);
4035                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
4036                 a2ActionParser->SetAction(A2Action);
4037                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
4038                 a3ActionParser->SetAction(A3Action);
4039                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
4040                 a4ActionParser->SetAction(A4Action);
4041                 NonterminalParser* templateIdNonterminalParser = GetNonterminal(ToUtf32("TemplateId"));
4042                 templateIdNonterminalParser->SetPre(PreTemplateId);
4043                 templateIdNonterminalParser->SetPost(PostTemplateId);
4044                 NonterminalParser* id1NonterminalParser = GetNonterminal(ToUtf32("id1"));
4045                 id1NonterminalParser->SetPost(Postid1);
4046                 NonterminalParser* operatorFunctionIdNonterminalParser = GetNonterminal(ToUtf32("OperatorFunctionId"));
4047                 operatorFunctionIdNonterminalParser->SetPost(PostOperatorFunctionId);
4048                 NonterminalParser* conversionFunctionIdNonterminalParser = GetNonterminal(ToUtf32("ConversionFunctionId"));
4049                 conversionFunctionIdNonterminalParser->SetPre(PreConversionFunctionId);
4050                 conversionFunctionIdNonterminalParser->SetPost(PostConversionFunctionId);
4051                 NonterminalParser* id2NonterminalParser = GetNonterminal(ToUtf32("id2"));
4052                 id2NonterminalParser->SetPost(Postid2);
4053             }
4054             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4055             {
4056                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4057                 context->value = context->fromTemplateId;
4058             }
4059             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4060             {
4061                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4062                 context->value = context->fromid1;
4063             }
4064             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4065             {
4066                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4067                 context->value = context->fromOperatorFunctionId;
4068             }
4069             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4070             {
4071                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4072                 context->value = context->fromConversionFunctionId;
4073             }
4074             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4075             {
4076                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4077                 context->value = new DestructorIdNode(span, context->fromid2);
4078             }
4079             public void PreTemplateId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4080             {
4081                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4082                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4083             }
4084             public void PostTemplateId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4085             {
4086                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4087                 if (matched)
4088                 {
4089                     UniquePtr<Object> fromTemplateId_value = stack.Pop();
4090                     context->fromTemplateId = *cast<ValueObject<TemplateIdNode*>*>(fromTemplateId_value.Get());
4091                 }
4092             }
4093             public void Postid1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4094             {
4095                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4096                 if (matched)
4097                 {
4098                     UniquePtr<Object> fromid1_value = stack.Pop();
4099                     context->fromid1 = *cast<ValueObject<IdentifierNode*>*>(fromid1_value.Get());
4100                 }
4101             }
4102             public void PostOperatorFunctionId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4103             {
4104                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4105                 if (matched)
4106                 {
4107                     UniquePtr<Object> fromOperatorFunctionId_value = stack.Pop();
4108                     context->fromOperatorFunctionId = *cast<ValueObject<OperatorFunctionIdNode*>*>(fromOperatorFunctionId_value.Get());
4109                 }
4110             }
4111             public void PreConversionFunctionId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4112             {
4113                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4114                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4115             }
4116             public void PostConversionFunctionId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4117             {
4118                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4119                 if (matched)
4120                 {
4121                     UniquePtr<Object> fromConversionFunctionId_value = stack.Pop();
4122                     context->fromConversionFunctionId = *cast<ValueObject<ConversionFunctionIdNode*>*>(fromConversionFunctionId_value.Get());
4123                 }
4124             }
4125             public void Postid2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4126             {
4127                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4128                 if (matched)
4129                 {
4130                     UniquePtr<Object> fromid2_value = stack.Pop();
4131                     context->fromid2 = *cast<ValueObject<IdentifierNode*>*>(fromid2_value.Get());
4132                 }
4133             }
4134             public class Context : System.Text.Parsing.Context
4135             {
4136                 public Context() : ctx(), value(), fromTemplateId(), fromid1(), fromOperatorFunctionId(), fromConversionFunctionId(), fromid2()
4137                 {
4138                 }
4139                 public ParsingContext* ctx;
4140                 public Node* value;
4141                 public TemplateIdNode* fromTemplateId;
4142                 public IdentifierNode* fromid1;
4143                 public OperatorFunctionIdNode* fromOperatorFunctionId;
4144                 public ConversionFunctionIdNode* fromConversionFunctionId;
4145                 public IdentifierNode* fromid2;
4146             }
4147         }
4148 
4149         public class QualifiedIdExprRule : System.Text.Parsing.RuleParser
4150         {
4151             public QualifiedIdExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4152             {
4153                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
4154                 SetValueTypeName(ToUtf32("Node*"));
4155             }
4156             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4157             {
4158                 parsingData->PushContext(Id(), new Context());
4159                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4160                 UniquePtr<Object> ctx_value = stack.Pop();
4161                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
4162             }
4163             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4164             {
4165                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4166                 if (matched)
4167                 {
4168                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
4169                 }
4170                 parsingData->PopContext(Id());
4171             }
4172             public override void Link()
4173             {
4174                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4175                 a0ActionParser->SetAction(A0Action);
4176                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
4177                 a1ActionParser->SetAction(A1Action);
4178                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
4179                 a2ActionParser->SetAction(A2Action);
4180                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
4181                 a3ActionParser->SetAction(A3Action);
4182                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
4183                 a4ActionParser->SetAction(A4Action);
4184                 NonterminalParser* templateIdNonterminalParser = GetNonterminal(ToUtf32("TemplateId"));
4185                 templateIdNonterminalParser->SetPre(PreTemplateId);
4186                 templateIdNonterminalParser->SetPost(PostTemplateId);
4187                 NonterminalParser* nsNonterminalParser = GetNonterminal(ToUtf32("ns"));
4188                 nsNonterminalParser->SetPre(Prens);
4189                 nsNonterminalParser->SetPost(Postns);
4190                 NonterminalParser* ud1NonterminalParser = GetNonterminal(ToUtf32("ud1"));
4191                 ud1NonterminalParser->SetPre(Preud1);
4192                 ud1NonterminalParser->SetPost(Postud1);
4193                 NonterminalParser* identifierNonterminalParser = GetNonterminal(ToUtf32("Identifier"));
4194                 identifierNonterminalParser->SetPost(PostIdentifier);
4195                 NonterminalParser* operatorFunctionIdNonterminalParser = GetNonterminal(ToUtf32("OperatorFunctionId"));
4196                 operatorFunctionIdNonterminalParser->SetPost(PostOperatorFunctionId);
4197                 NonterminalParser* ns2NonterminalParser = GetNonterminal(ToUtf32("ns2"));
4198                 ns2NonterminalParser->SetPre(Prens2);
4199                 ns2NonterminalParser->SetPost(Postns2);
4200                 NonterminalParser* uid2NonterminalParser = GetNonterminal(ToUtf32("uid2"));
4201                 uid2NonterminalParser->SetPre(Preuid2);
4202                 uid2NonterminalParser->SetPost(Postuid2);
4203             }
4204             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4205             {
4206                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4207                 context->value = new ColonColonNode(span, null, context->fromTemplateId);
4208             }
4209             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4210             {
4211                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4212                 context->value = new ColonColonNode(span, null, new ColonColonNode(span, context->fromns, context->fromud1));
4213             }
4214             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4215             {
4216                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4217                 context->value = new ColonColonNode(span, null, context->fromIdentifier);
4218             }
4219             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4220             {
4221                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4222                 context->value = new ColonColonNode(span, null, context->fromOperatorFunctionId);
4223             }
4224             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4225             {
4226                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4227                 context->value = new ColonColonNode(span, context->fromns2, context->fromuid2);
4228             }
4229             public void PreTemplateId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4230             {
4231                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4232                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4233             }
4234             public void PostTemplateId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4235             {
4236                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4237                 if (matched)
4238                 {
4239                     UniquePtr<Object> fromTemplateId_value = stack.Pop();
4240                     context->fromTemplateId = *cast<ValueObject<TemplateIdNode*>*>(fromTemplateId_value.Get());
4241                 }
4242             }
4243             public void Prens(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4244             {
4245                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4246                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4247             }
4248             public void Postns(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4249             {
4250                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4251                 if (matched)
4252                 {
4253                     UniquePtr<Object> fromns_value = stack.Pop();
4254                     context->fromns = *cast<ValueObject<Node*>*>(fromns_value.Get());
4255                 }
4256             }
4257             public void Preud1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4258             {
4259                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4260                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4261             }
4262             public void Postud1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4263             {
4264                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4265                 if (matched)
4266                 {
4267                     UniquePtr<Object> fromud1_value = stack.Pop();
4268                     context->fromud1 = *cast<ValueObject<Node*>*>(fromud1_value.Get());
4269                 }
4270             }
4271             public void PostIdentifier(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4272             {
4273                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4274                 if (matched)
4275                 {
4276                     UniquePtr<Object> fromIdentifier_value = stack.Pop();
4277                     context->fromIdentifier = *cast<ValueObject<IdentifierNode*>*>(fromIdentifier_value.Get());
4278                 }
4279             }
4280             public void PostOperatorFunctionId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4281             {
4282                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4283                 if (matched)
4284                 {
4285                     UniquePtr<Object> fromOperatorFunctionId_value = stack.Pop();
4286                     context->fromOperatorFunctionId = *cast<ValueObject<OperatorFunctionIdNode*>*>(fromOperatorFunctionId_value.Get());
4287                 }
4288             }
4289             public void Prens2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4290             {
4291                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4292                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4293             }
4294             public void Postns2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4295             {
4296                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4297                 if (matched)
4298                 {
4299                     UniquePtr<Object> fromns2_value = stack.Pop();
4300                     context->fromns2 = *cast<ValueObject<Node*>*>(fromns2_value.Get());
4301                 }
4302             }
4303             public void Preuid2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4304             {
4305                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4306                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4307             }
4308             public void Postuid2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4309             {
4310                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4311                 if (matched)
4312                 {
4313                     UniquePtr<Object> fromuid2_value = stack.Pop();
4314                     context->fromuid2 = *cast<ValueObject<Node*>*>(fromuid2_value.Get());
4315                 }
4316             }
4317             public class Context : System.Text.Parsing.Context
4318             {
4319                 public Context() : ctx(), value(), fromTemplateId(), fromns(), fromud1(), fromIdentifier(), fromOperatorFunctionId(), fromns2(), fromuid2()
4320                 {
4321                 }
4322                 public ParsingContext* ctx;
4323                 public Node* value;
4324                 public TemplateIdNode* fromTemplateId;
4325                 public Node* fromns;
4326                 public Node* fromud1;
4327                 public IdentifierNode* fromIdentifier;
4328                 public OperatorFunctionIdNode* fromOperatorFunctionId;
4329                 public Node* fromns2;
4330                 public Node* fromuid2;
4331             }
4332         }
4333 
4334         public class OperatorFunctionIdRule : System.Text.Parsing.RuleParser
4335         {
4336             public OperatorFunctionIdRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4337             {
4338                 SetValueTypeName(ToUtf32("OperatorFunctionIdNode*"));
4339             }
4340             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4341             {
4342                 parsingData->PushContext(Id(), new Context());
4343                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4344             }
4345             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4346             {
4347                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4348                 if (matched)
4349                 {
4350                     stack.Push(UniquePtr<Object>(new ValueObject<OperatorFunctionIdNode*>(context->value)));
4351                 }
4352                 parsingData->PopContext(Id());
4353             }
4354             public override void Link()
4355             {
4356                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4357                 a0ActionParser->SetAction(A0Action);
4358                 NonterminalParser* operatorNonterminalParser = GetNonterminal(ToUtf32("Operator"));
4359                 operatorNonterminalParser->SetPost(PostOperator);
4360             }
4361             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4362             {
4363                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4364                 context->value = new OperatorFunctionIdNode(span, context->fromOperator);
4365             }
4366             public void PostOperator(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4367             {
4368                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4369                 if (matched)
4370                 {
4371                     UniquePtr<Object> fromOperator_value = stack.Pop();
4372                     context->fromOperator = *cast<ValueObject<Operator>*>(fromOperator_value.Get());
4373                 }
4374             }
4375             public class Context : System.Text.Parsing.Context
4376             {
4377                 public Context() : value(), fromOperator()
4378                 {
4379                 }
4380                 public OperatorFunctionIdNode* value;
4381                 public Operator fromOperator;
4382             }
4383         }
4384 
4385         public class OperatorRule : System.Text.Parsing.RuleParser
4386         {
4387             public OperatorRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4388             {
4389                 SetValueTypeName(ToUtf32("Operator"));
4390             }
4391             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4392             {
4393                 parsingData->PushContext(Id(), new Context());
4394                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4395             }
4396             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4397             {
4398                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4399                 if (matched)
4400                 {
4401                     stack.Push(UniquePtr<Object>(new ValueObject<Operator>(context->value)));
4402                 }
4403                 parsingData->PopContext(Id());
4404             }
4405             public override void Link()
4406             {
4407                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4408                 a0ActionParser->SetAction(A0Action);
4409                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
4410                 a1ActionParser->SetAction(A1Action);
4411                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
4412                 a2ActionParser->SetAction(A2Action);
4413                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
4414                 a3ActionParser->SetAction(A3Action);
4415                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
4416                 a4ActionParser->SetAction(A4Action);
4417                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
4418                 a5ActionParser->SetAction(A5Action);
4419                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
4420                 a6ActionParser->SetAction(A6Action);
4421                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
4422                 a7ActionParser->SetAction(A7Action);
4423                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
4424                 a8ActionParser->SetAction(A8Action);
4425                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
4426                 a9ActionParser->SetAction(A9Action);
4427                 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
4428                 a10ActionParser->SetAction(A10Action);
4429                 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
4430                 a11ActionParser->SetAction(A11Action);
4431                 ActionParser* a12ActionParser = GetAction(ToUtf32("A12"));
4432                 a12ActionParser->SetAction(A12Action);
4433                 ActionParser* a13ActionParser = GetAction(ToUtf32("A13"));
4434                 a13ActionParser->SetAction(A13Action);
4435                 ActionParser* a14ActionParser = GetAction(ToUtf32("A14"));
4436                 a14ActionParser->SetAction(A14Action);
4437                 ActionParser* a15ActionParser = GetAction(ToUtf32("A15"));
4438                 a15ActionParser->SetAction(A15Action);
4439                 ActionParser* a16ActionParser = GetAction(ToUtf32("A16"));
4440                 a16ActionParser->SetAction(A16Action);
4441                 ActionParser* a17ActionParser = GetAction(ToUtf32("A17"));
4442                 a17ActionParser->SetAction(A17Action);
4443                 ActionParser* a18ActionParser = GetAction(ToUtf32("A18"));
4444                 a18ActionParser->SetAction(A18Action);
4445                 ActionParser* a19ActionParser = GetAction(ToUtf32("A19"));
4446                 a19ActionParser->SetAction(A19Action);
4447                 ActionParser* a20ActionParser = GetAction(ToUtf32("A20"));
4448                 a20ActionParser->SetAction(A20Action);
4449                 ActionParser* a21ActionParser = GetAction(ToUtf32("A21"));
4450                 a21ActionParser->SetAction(A21Action);
4451                 ActionParser* a22ActionParser = GetAction(ToUtf32("A22"));
4452                 a22ActionParser->SetAction(A22Action);
4453                 ActionParser* a23ActionParser = GetAction(ToUtf32("A23"));
4454                 a23ActionParser->SetAction(A23Action);
4455                 ActionParser* a24ActionParser = GetAction(ToUtf32("A24"));
4456                 a24ActionParser->SetAction(A24Action);
4457                 ActionParser* a25ActionParser = GetAction(ToUtf32("A25"));
4458                 a25ActionParser->SetAction(A25Action);
4459                 ActionParser* a26ActionParser = GetAction(ToUtf32("A26"));
4460                 a26ActionParser->SetAction(A26Action);
4461                 ActionParser* a27ActionParser = GetAction(ToUtf32("A27"));
4462                 a27ActionParser->SetAction(A27Action);
4463                 ActionParser* a28ActionParser = GetAction(ToUtf32("A28"));
4464                 a28ActionParser->SetAction(A28Action);
4465                 ActionParser* a29ActionParser = GetAction(ToUtf32("A29"));
4466                 a29ActionParser->SetAction(A29Action);
4467                 ActionParser* a30ActionParser = GetAction(ToUtf32("A30"));
4468                 a30ActionParser->SetAction(A30Action);
4469                 ActionParser* a31ActionParser = GetAction(ToUtf32("A31"));
4470                 a31ActionParser->SetAction(A31Action);
4471                 ActionParser* a32ActionParser = GetAction(ToUtf32("A32"));
4472                 a32ActionParser->SetAction(A32Action);
4473                 NonterminalParser* assignmentOperatorNonterminalParser = GetNonterminal(ToUtf32("AssignmentOperator"));
4474                 assignmentOperatorNonterminalParser->SetPost(PostAssignmentOperator);
4475             }
4476             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4477             {
4478                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4479                 context->value = Operator.arrayNew;
4480             }
4481             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4482             {
4483                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4484                 context->value = Operator.arrayDelete;
4485             }
4486             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4487             {
4488                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4489                 context->value = Operator.new_;
4490             }
4491             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4492             {
4493                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4494                 context->value = Operator.delete_;
4495             }
4496             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4497             {
4498                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4499                 context->value = context->fromAssignmentOperator;
4500             }
4501             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4502             {
4503                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4504                 context->value = Operator.inc;
4505             }
4506             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4507             {
4508                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4509                 context->value = Operator.dec;
4510             }
4511             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4512             {
4513                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4514                 context->value = Operator.shiftLeft;
4515             }
4516             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4517             {
4518                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4519                 context->value = Operator.shiftRight;
4520             }
4521             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4522             {
4523                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4524                 context->value = Operator.logicalAnd;
4525             }
4526             public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4527             {
4528                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4529                 context->value = Operator.logicalOr;
4530             }
4531             public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4532             {
4533                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4534                 context->value = Operator.equal;
4535             }
4536             public void A12Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4537             {
4538                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4539                 context->value = Operator.notEqual;
4540             }
4541             public void A13Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4542             {
4543                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4544                 context->value = Operator.lessOrEqual;
4545             }
4546             public void A14Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4547             {
4548                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4549                 context->value = Operator.greaterOrEqual;
4550             }
4551             public void A15Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4552             {
4553                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4554                 context->value = Operator.dotStar;
4555             }
4556             public void A16Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4557             {
4558                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4559                 context->value = Operator.arrowStar;
4560             }
4561             public void A17Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4562             {
4563                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4564                 context->value = Operator.arrow;
4565             }
4566             public void A18Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4567             {
4568                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4569                 context->value = Operator.apply;
4570             }
4571             public void A19Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4572             {
4573                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4574                 context->value = Operator.subscript;
4575             }
4576             public void A20Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4577             {
4578                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4579                 context->value = Operator.less;
4580             }
4581             public void A21Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4582             {
4583                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4584                 context->value = Operator.greater;
4585             }
4586             public void A22Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4587             {
4588                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4589                 context->value = Operator.add;
4590             }
4591             public void A23Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4592             {
4593                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4594                 context->value = Operator.sub;
4595             }
4596             public void A24Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4597             {
4598                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4599                 context->value = Operator.mul;
4600             }
4601             public void A25Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4602             {
4603                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4604                 context->value = Operator.div;
4605             }
4606             public void A26Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4607             {
4608                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4609                 context->value = Operator.rem;
4610             }
4611             public void A27Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4612             {
4613                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4614                 context->value = Operator.xor;
4615             }
4616             public void A28Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4617             {
4618                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4619                 context->value = Operator.and_;
4620             }
4621             public void A29Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4622             {
4623                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4624                 context->value = Operator.or_;
4625             }
4626             public void A30Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4627             {
4628                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4629                 context->value = Operator.neg;
4630             }
4631             public void A31Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4632             {
4633                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4634                 context->value = Operator.not_;
4635             }
4636             public void A32Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4637             {
4638                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4639                 context->value = Operator.comma;
4640             }
4641             public void PostAssignmentOperator(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4642             {
4643                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4644                 if (matched)
4645                 {
4646                     UniquePtr<Object> fromAssignmentOperator_value = stack.Pop();
4647                     context->fromAssignmentOperator = *cast<ValueObject<Operator>*>(fromAssignmentOperator_value.Get());
4648                 }
4649             }
4650             public class Context : System.Text.Parsing.Context
4651             {
4652                 public Context() : value(), fromAssignmentOperator()
4653                 {
4654                 }
4655                 public Operator value;
4656                 public Operator fromAssignmentOperator;
4657             }
4658         }
4659 
4660         public class ConversionFunctionIdRule : System.Text.Parsing.RuleParser
4661         {
4662             public ConversionFunctionIdRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4663             {
4664                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
4665                 SetValueTypeName(ToUtf32("ConversionFunctionIdNode*"));
4666             }
4667             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4668             {
4669                 parsingData->PushContext(Id(), new Context());
4670                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4671                 UniquePtr<Object> ctx_value = stack.Pop();
4672                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
4673             }
4674             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4675             {
4676                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4677                 if (matched)
4678                 {
4679                     stack.Push(UniquePtr<Object>(new ValueObject<ConversionFunctionIdNode*>(context->value)));
4680                 }
4681                 parsingData->PopContext(Id());
4682             }
4683             public override void Link()
4684             {
4685                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4686                 a0ActionParser->SetAction(A0Action);
4687                 NonterminalParser* typeExprNonterminalParser = GetNonterminal(ToUtf32("TypeExpr"));
4688                 typeExprNonterminalParser->SetPre(PreTypeExpr);
4689                 typeExprNonterminalParser->SetPost(PostTypeExpr);
4690             }
4691             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4692             {
4693                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4694                 context->value = new ConversionFunctionIdNode(span, context->fromTypeExpr);
4695             }
4696             public void PreTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4697             {
4698                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4699                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4700             }
4701             public void PostTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4702             {
4703                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4704                 if (matched)
4705                 {
4706                     UniquePtr<Object> fromTypeExpr_value = stack.Pop();
4707                     context->fromTypeExpr = *cast<ValueObject<Node*>*>(fromTypeExpr_value.Get());
4708                 }
4709             }
4710             public class Context : System.Text.Parsing.Context
4711             {
4712                 public Context() : ctx(), value(), fromTypeExpr()
4713                 {
4714                 }
4715                 public ParsingContext* ctx;
4716                 public ConversionFunctionIdNode* value;
4717                 public Node* fromTypeExpr;
4718             }
4719         }
4720 
4721         public class LambdaExpressionRule : System.Text.Parsing.RuleParser
4722         {
4723             public LambdaExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4724             {
4725                 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
4726                 SetValueTypeName(ToUtf32("LambdaExpressionNode*"));
4727             }
4728             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4729             {
4730                 parsingData->PushContext(Id(), new Context());
4731                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4732                 UniquePtr<Object> ctx_value = stack.Pop();
4733                 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
4734             }
4735             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4736             {
4737                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4738                 if (matched)
4739                 {
4740                     stack.Push(UniquePtr<Object>(new ValueObject<LambdaExpressionNode*>(context->value)));
4741                 }
4742                 parsingData->PopContext(Id());
4743             }
4744             public override void Link()
4745             {
4746                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4747                 a0ActionParser->SetAction(A0Action);
4748                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
4749                 a1ActionParser->SetAction(A1Action);
4750                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
4751                 a2ActionParser->SetAction(A2Action);
4752                 NonterminalParser* lambdaCapturesNonterminalParser = GetNonterminal(ToUtf32("LambdaCaptures"));
4753                 lambdaCapturesNonterminalParser->SetPre(PreLambdaCaptures);
4754                 NonterminalParser* parameterListNonterminalParser = GetNonterminal(ToUtf32("ParameterList"));
4755                 parameterListNonterminalParser->SetPre(PreParameterList);
4756                 parameterListNonterminalParser->SetPost(PostParameterList);
4757                 NonterminalParser* compoundStatementNonterminalParser = GetNonterminal(ToUtf32("CompoundStatement"));
4758                 compoundStatementNonterminalParser->SetPre(PreCompoundStatement);
4759                 compoundStatementNonterminalParser->SetPost(PostCompoundStatement);
4760             }
4761             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4762             {
4763                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4764                 context->value = new LambdaExpressionNode(span);
4765             }
4766             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4767             {
4768                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4769                 context->value->SetParameters(context->fromParameterList);
4770             }
4771             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4772             {
4773                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4774                 context->value->SetBody(context->fromCompoundStatement);
4775             }
4776             public void PreLambdaCaptures(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4777             {
4778                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4779                 stack.Push(UniquePtr<Object>(new ValueObject<LambdaExpressionNode*>(context->value)));
4780             }
4781             public void PreParameterList(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4782             {
4783                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4784                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4785             }
4786             public void PostParameterList(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4787             {
4788                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4789                 if (matched)
4790                 {
4791                     UniquePtr<Object> fromParameterList_value = stack.Pop();
4792                     context->fromParameterList = *cast<ValueObject<ParameterListNode*>*>(fromParameterList_value.Get());
4793                 }
4794             }
4795             public void PreCompoundStatement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4796             {
4797                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4798                 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4799             }
4800             public void PostCompoundStatement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4801             {
4802                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4803                 if (matched)
4804                 {
4805                     UniquePtr<Object> fromCompoundStatement_value = stack.Pop();
4806                     context->fromCompoundStatement = *cast<ValueObject<CompoundStatementNode*>*>(fromCompoundStatement_value.Get());
4807                 }
4808             }
4809             public class Context : System.Text.Parsing.Context
4810             {
4811                 public Context() : ctx(), value(), fromParameterList(), fromCompoundStatement()
4812                 {
4813                 }
4814                 public ParsingContext* ctx;
4815                 public LambdaExpressionNode* value;
4816                 public ParameterListNode* fromParameterList;
4817                 public CompoundStatementNode* fromCompoundStatement;
4818             }
4819         }
4820 
4821         public class LambdaCapturesRule : System.Text.Parsing.RuleParser
4822         {
4823             public LambdaCapturesRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4824             {
4825                 AddInheritedAttribute(AttrOrVar(ToUtf32("LambdaExpressionNode*"), ToUtf32("lambdaExpression")));
4826             }
4827             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4828             {
4829                 parsingData->PushContext(Id(), new Context());
4830                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4831                 UniquePtr<Object> lambdaExpression_value = stack.Pop();
4832                 context->lambdaExpression = *cast<ValueObject<LambdaExpressionNode*>*>(lambdaExpression_value.Get());
4833             }
4834             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4835             {
4836                 parsingData->PopContext(Id());
4837             }
4838             public override void Link()
4839             {
4840                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4841                 a0ActionParser->SetAction(A0Action);
4842                 NonterminalParser* captureDefaultNonterminalParser = GetNonterminal(ToUtf32("CaptureDefault"));
4843                 captureDefaultNonterminalParser->SetPost(PostCaptureDefault);
4844                 NonterminalParser* capturesNonterminalParser = GetNonterminal(ToUtf32("Captures"));
4845                 capturesNonterminalParser->SetPre(PreCaptures);
4846             }
4847             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4848             {
4849                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4850                 context->lambdaExpression->AddCapture(context->fromCaptureDefault);
4851             }
4852             public void PostCaptureDefault(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4853             {
4854                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4855                 if (matched)
4856                 {
4857                     UniquePtr<Object> fromCaptureDefault_value = stack.Pop();
4858                     context->fromCaptureDefault = *cast<ValueObject<Node*>*>(fromCaptureDefault_value.Get());
4859                 }
4860             }
4861             public void PreCaptures(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4862             {
4863                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4864                 stack.Push(UniquePtr<Object>(new ValueObject<LambdaExpressionNode*>(context->lambdaExpression)));
4865             }
4866             public class Context : System.Text.Parsing.Context
4867             {
4868                 public Context() : lambdaExpression(), fromCaptureDefault()
4869                 {
4870                 }
4871                 public LambdaExpressionNode* lambdaExpression;
4872                 public Node* fromCaptureDefault;
4873             }
4874         }
4875 
4876         public class CaptureDefaultRule : System.Text.Parsing.RuleParser
4877         {
4878             public CaptureDefaultRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4879             {
4880                 SetValueTypeName(ToUtf32("Node*"));
4881             }
4882             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4883             {
4884                 parsingData->PushContext(Id(), new Context());
4885                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4886             }
4887             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4888             {
4889                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4890                 if (matched)
4891                 {
4892                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
4893                 }
4894                 parsingData->PopContext(Id());
4895             }
4896             public override void Link()
4897             {
4898                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4899                 a0ActionParser->SetAction(A0Action);
4900                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
4901                 a1ActionParser->SetAction(A1Action);
4902             }
4903             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4904             {
4905                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4906                 context->value = new AssignCapture(span);
4907             }
4908             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4909             {
4910                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4911                 context->value = new RefCapture(span);
4912             }
4913             public class Context : System.Text.Parsing.Context
4914             {
4915                 public Context() : value()
4916                 {
4917                 }
4918                 public Node* value;
4919             }
4920         }
4921 
4922         public class CapturesRule : System.Text.Parsing.RuleParser
4923         {
4924             public CapturesRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4925             {
4926                 AddInheritedAttribute(AttrOrVar(ToUtf32("LambdaExpressionNode*"), ToUtf32("lambdaExpression")));
4927             }
4928             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4929             {
4930                 parsingData->PushContext(Id(), new Context());
4931                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4932                 UniquePtr<Object> lambdaExpression_value = stack.Pop();
4933                 context->lambdaExpression = *cast<ValueObject<LambdaExpressionNode*>*>(lambdaExpression_value.Get());
4934             }
4935             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4936             {
4937                 parsingData->PopContext(Id());
4938             }
4939             public override void Link()
4940             {
4941                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4942                 a0ActionParser->SetAction(A0Action);
4943                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
4944                 a1ActionParser->SetAction(A1Action);
4945                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
4946                 leftNonterminalParser->SetPost(Postleft);
4947                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
4948                 rightNonterminalParser->SetPost(Postright);
4949             }
4950             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4951             {
4952                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4953                 context->lambdaExpression->AddCapture(context->fromleft);
4954             }
4955             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4956             {
4957                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4958                 context->lambdaExpression->AddCapture(context->fromright);
4959             }
4960             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4961             {
4962                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4963                 if (matched)
4964                 {
4965                     UniquePtr<Object> fromleft_value = stack.Pop();
4966                     context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
4967                 }
4968             }
4969             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4970             {
4971                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4972                 if (matched)
4973                 {
4974                     UniquePtr<Object> fromright_value = stack.Pop();
4975                     context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
4976                 }
4977             }
4978             public class Context : System.Text.Parsing.Context
4979             {
4980                 public Context() : lambdaExpression(), fromleft(), fromright()
4981                 {
4982                 }
4983                 public LambdaExpressionNode* lambdaExpression;
4984                 public Node* fromleft;
4985                 public Node* fromright;
4986             }
4987         }
4988 
4989         public class CaptureRule : System.Text.Parsing.RuleParser
4990         {
4991             public CaptureRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4992             {
4993                 SetValueTypeName(ToUtf32("Node*"));
4994             }
4995             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4996             {
4997                 parsingData->PushContext(Id(), new Context());
4998                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4999             }
5000             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5001             {
5002                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5003                 if (matched)
5004                 {
5005                     stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
5006                 }
5007                 parsingData->PopContext(Id());
5008             }
5009             public override void Link()
5010             {
5011                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5012                 a0ActionParser->SetAction(A0Action);
5013                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
5014                 a1ActionParser->SetAction(A1Action);
5015                 NonterminalParser* identifierNonterminalParser = GetNonterminal(ToUtf32("Identifier"));
5016                 identifierNonterminalParser->SetPost(PostIdentifier);
5017             }
5018             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5019             {
5020                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5021                 context->value = new IdentifierCapture(span, context->fromIdentifier);
5022             }
5023             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5024             {
5025                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5026                 context->value = new ThisCapture(span);
5027             }
5028             public void PostIdentifier(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5029             {
5030                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5031                 if (matched)
5032                 {
5033                     UniquePtr<Object> fromIdentifier_value = stack.Pop();
5034                     context->fromIdentifier = *cast<ValueObject<IdentifierNode*>*>(fromIdentifier_value.Get());
5035                 }
5036             }
5037             public class Context : System.Text.Parsing.Context
5038             {
5039                 public Context() : value(), fromIdentifier()
5040                 {
5041                 }
5042                 public Node* value;
5043                 public IdentifierNode* fromIdentifier;
5044             }
5045         }
5046 
5047         public override void GetReferencedGrammars()
5048         {
5049             ParsingDomain* pd = Domain();
5050             Grammar* grammar0 = pd->GetGrammar(ToUtf32("cppparser.FunctionGrammar"));
5051             if (grammar0 == null)
5052             {
5053                 grammar0 = new cppparser.FunctionGrammar(pd);
5054             }
5055             AddGrammarReference(grammar0);
5056             Grammar* grammar1 = pd->GetGrammar(ToUtf32("cppparser.TemplateGrammar"));
5057             if (grammar1 == null)
5058             {
5059                 grammar1 = new cppparser.TemplateGrammar(pd);
5060             }
5061             AddGrammarReference(grammar1);
5062             Grammar* grammar2 = pd->GetGrammar(ToUtf32("cppparser.StatementGrammar"));
5063             if (grammar2 == null)
5064             {
5065                 grammar2 = new cppparser.StatementGrammar(pd);
5066             }
5067             AddGrammarReference(grammar2);
5068             Grammar* grammar3 = pd->GetGrammar(ToUtf32("cppparser.IdentifierGrammar"));
5069             if (grammar3 == null)
5070             {
5071                 grammar3 = new cppparser.IdentifierGrammar(pd);
5072             }
5073             AddGrammarReference(grammar3);
5074             Grammar* grammar4 = pd->GetGrammar(ToUtf32("System.Text.Parsing.stdlib"));
5075             if (grammar4 == null)
5076             {
5077                 grammar4 = new System.Text.Parsing.stdlib(pd);
5078             }
5079             AddGrammarReference(grammar4);
5080             Grammar* grammar5 = pd->GetGrammar(ToUtf32("cppparser.TypeExprGrammar"));
5081             if (grammar5 == null)
5082             {
5083                 grammar5 = new cppparser.TypeExprGrammar(pd);
5084             }
5085             AddGrammarReference(grammar5);
5086             Grammar* grammar6 = pd->GetGrammar(ToUtf32("cppparser.DeclaratorGrammar"));
5087             if (grammar6 == null)
5088             {
5089                 grammar6 = new cppparser.DeclaratorGrammar(pd);
5090             }
5091             AddGrammarReference(grammar6);
5092             Grammar* grammar7 = pd->GetGrammar(ToUtf32("cppparser.SimpleTypeGrammar"));
5093             if (grammar7 == null)
5094             {
5095                 grammar7 = new cppparser.SimpleTypeGrammar(pd);
5096             }
5097             AddGrammarReference(grammar7);
5098             Grammar* grammar8 = pd->GetGrammar(ToUtf32("cppparser.LiteralGrammar"));
5099             if (grammar8 == null)
5100             {
5101                 grammar8 = new cppparser.LiteralGrammar(pd);
5102             }
5103             AddGrammarReference(grammar8);
5104         }
5105         public override void CreateRules()
5106         {
5107             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("InitializerList"), this, ToUtf32("DeclaratorGrammar.InitializerList")));
5108             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("InitializerClause"), this, ToUtf32("DeclaratorGrammar.InitializerClause")));
5109             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("BracedInitializerList"), this, ToUtf32("DeclaratorGrammar.BracedInitializerList")));
5110             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("TypeExpr"), this, ToUtf32("TypeExprGrammar.TypeExpr")));
5111             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("SimpleType"), this, ToUtf32("SimpleTypeGrammar.SimpleType")));
5112             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("Literal"), this, ToUtf32("LiteralGrammar.Literal")));
5113             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("SimpleTypeSpecifier"), this, ToUtf32("SimpleTypeGrammar.SimpleTypeSpecifier")));
5114             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("TemplateId"), this, ToUtf32("TemplateGrammar.TemplateId")));
5115             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("Identifier"), this, ToUtf32("IdentifierGrammar.Identifier")));
5116             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("NestedNameSpecifier"), this, ToUtf32("IdentifierGrammar.NestedNameSpecifier")));
5117             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("ParameterList"), this, ToUtf32("FunctionGrammar.ParameterList")));
5118             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("CompoundStatement"), this, ToUtf32("StatementGrammar.CompoundStatement")));
5119             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("identifier"), this, ToUtf32("System.Text.Parsing.stdlib.identifier")));
5120             AddRule(new ExpressionListRule(ToUtf32("ExpressionList"), GetScope(), Domain()->GetNextRuleId(), 
5121                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5122                     new System.Text.Parsing.GroupingParser(
5123                         new System.Text.Parsing.SequenceParser(
5124                             new System.Text.Parsing.SequenceParser(
5125                                 new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5126                                     new System.Text.Parsing.EmptyParser()), 
5127                                 new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5128                                     new System.Text.Parsing.NonterminalParser(ToUtf32("ic1"), ToUtf32("InitializerClause"), 1))), 
5129                             new System.Text.Parsing.KleeneStarParser(
5130                                 new System.Text.Parsing.GroupingParser(
5131                                     new System.Text.Parsing.SequenceParser(
5132                                         new System.Text.Parsing.CharParser(','), 
5133                                         new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5134                                             new System.Text.Parsing.NonterminalParser(ToUtf32("ic2"), ToUtf32("InitializerClause"), 1))))))))));
5135             AddRule(new PossiblyEmptyArgumentListRule(ToUtf32("PossiblyEmptyArgumentList"), GetScope(), Domain()->GetNextRuleId(), 
5136                 new System.Text.Parsing.AlternativeParser(
5137                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5138                         new System.Text.Parsing.NonterminalParser(ToUtf32("ExpressionList"), ToUtf32("ExpressionList"), 1)), 
5139                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5140                         new System.Text.Parsing.EmptyParser()))));
5141             AddRule(new ExpressionRule(ToUtf32("Expression"), GetScope(), Domain()->GetNextRuleId(), 
5142                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5143                     new System.Text.Parsing.GroupingParser(
5144                         new System.Text.Parsing.SequenceParser(
5145                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5146                                 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("AssignmentExpression"), 1)), 
5147                             new System.Text.Parsing.KleeneStarParser(
5148                                 new System.Text.Parsing.GroupingParser(
5149                                     new System.Text.Parsing.SequenceParser(
5150                                         new System.Text.Parsing.CharParser(','), 
5151                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5152                                             new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("AssignmentExpression"), 1))))))))));
5153             AddRule(new ConstantExpressionRule(ToUtf32("ConstantExpression"), GetScope(), Domain()->GetNextRuleId(), 
5154                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5155                     new System.Text.Parsing.NonterminalParser(ToUtf32("ConditionalExpression"), ToUtf32("ConditionalExpression"), 1))));
5156             AddRule(new AssignmentExpressionRule(ToUtf32("AssignmentExpression"), GetScope(), Domain()->GetNextRuleId(), 
5157                 new System.Text.Parsing.AlternativeParser(
5158                     new System.Text.Parsing.AlternativeParser(
5159                         new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5160                             new System.Text.Parsing.NonterminalParser(ToUtf32("ConcreteAssignmentExpression"), ToUtf32("ConcreteAssignmentExpression"), 1)), 
5161                         new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5162                             new System.Text.Parsing.NonterminalParser(ToUtf32("ConditionalExpression"), ToUtf32("ConditionalExpression"), 1))), 
5163                     new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5164                         new System.Text.Parsing.NonterminalParser(ToUtf32("ThrowExpression"), ToUtf32("ThrowExpression"), 1)))));
5165             AddRule(new ConcreteAssignmentExpressionRule(ToUtf32("ConcreteAssignmentExpression"), GetScope(), Domain()->GetNextRuleId(), 
5166                 new System.Text.Parsing.SequenceParser(
5167                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5168                         new System.Text.Parsing.EmptyParser()), 
5169                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5170                         new System.Text.Parsing.GroupingParser(
5171                             new System.Text.Parsing.SequenceParser(
5172                                 new System.Text.Parsing.SequenceParser(
5173                                     new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5174                                         new System.Text.Parsing.NonterminalParser(ToUtf32("LogicalOrExpression"), ToUtf32("LogicalOrExpression"), 1)), 
5175                                     new System.Text.Parsing.NonterminalParser(ToUtf32("AssignmentOperator"), ToUtf32("AssignmentOperator"), 0)), 
5176                                 new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5177                                     new System.Text.Parsing.NonterminalParser(ToUtf32("InitializerClause"), ToUtf32("InitializerClause"), 1))))))));
5178             AddRule(new AssignmentOperatorRule(ToUtf32("AssignmentOperator"), GetScope(), Domain()->GetNextRuleId(), 
5179                 new System.Text.Parsing.AlternativeParser(
5180                     new System.Text.Parsing.AlternativeParser(
5181                         new System.Text.Parsing.AlternativeParser(
5182                             new System.Text.Parsing.AlternativeParser(
5183                                 new System.Text.Parsing.AlternativeParser(
5184                                     new System.Text.Parsing.AlternativeParser(
5185                                         new System.Text.Parsing.AlternativeParser(
5186                                             new System.Text.Parsing.AlternativeParser(
5187                                                 new System.Text.Parsing.AlternativeParser(
5188                                                     new System.Text.Parsing.AlternativeParser(
5189                                                         new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5190                                                             new System.Text.Parsing.GroupingParser(
5191                                                                 new System.Text.Parsing.DifferenceParser(
5192                                                                     new System.Text.Parsing.StringParser(ToUtf32("=")), 
5193                                                                     new System.Text.Parsing.StringParser(ToUtf32("=="))))), 
5194                                                         new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5195                                                             new System.Text.Parsing.StringParser(ToUtf32("*=")))), 
5196                                                     new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5197                                                         new System.Text.Parsing.StringParser(ToUtf32("/=")))), 
5198                                                 new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5199                                                     new System.Text.Parsing.StringParser(ToUtf32("%=")))), 
5200                                             new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5201                                                 new System.Text.Parsing.StringParser(ToUtf32("+=")))), 
5202                                         new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
5203                                             new System.Text.Parsing.StringParser(ToUtf32("-=")))), 
5204                                     new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
5205                                         new System.Text.Parsing.StringParser(ToUtf32(">>=")))), 
5206                                 new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
5207                                     new System.Text.Parsing.StringParser(ToUtf32("<<=")))), 
5208                             new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
5209                                 new System.Text.Parsing.StringParser(ToUtf32("&=")))), 
5210                         new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
5211                             new System.Text.Parsing.StringParser(ToUtf32("^=")))), 
5212                     new System.Text.Parsing.ActionParser(ToUtf32("A10"), 
5213                         new System.Text.Parsing.StringParser(ToUtf32("|="))))));
5214             AddRule(new ConditionalExpressionRule(ToUtf32("ConditionalExpression"), GetScope(), Domain()->GetNextRuleId(), 
5215                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5216                     new System.Text.Parsing.GroupingParser(
5217                         new System.Text.Parsing.SequenceParser(
5218                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5219                                 new System.Text.Parsing.NonterminalParser(ToUtf32("LogicalOrExpression"), ToUtf32("LogicalOrExpression"), 1)), 
5220                             new System.Text.Parsing.OptionalParser(
5221                                 new System.Text.Parsing.GroupingParser(
5222                                     new System.Text.Parsing.SequenceParser(
5223                                         new System.Text.Parsing.SequenceParser(
5224                                             new System.Text.Parsing.SequenceParser(
5225                                                 new System.Text.Parsing.CharParser('?'), 
5226                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("Expression"), ToUtf32("Expression"), 1)), 
5227                                             new System.Text.Parsing.CharParser(':')), 
5228                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5229                                             new System.Text.Parsing.NonterminalParser(ToUtf32("AssignmentExpression"), ToUtf32("AssignmentExpression"), 1))))))))));
5230             AddRule(new ThrowExpressionRule(ToUtf32("ThrowExpression"), GetScope(), Domain()->GetNextRuleId(), 
5231                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5232                     new System.Text.Parsing.GroupingParser(
5233                         new System.Text.Parsing.SequenceParser(
5234                             new System.Text.Parsing.KeywordParser(ToUtf32("throw")), 
5235                             new System.Text.Parsing.OptionalParser(
5236                                 new System.Text.Parsing.NonterminalParser(ToUtf32("AssignmentExpression"), ToUtf32("AssignmentExpression"), 1)))))));
5237             AddRule(new LogicalOrExpressionRule(ToUtf32("LogicalOrExpression"), GetScope(), Domain()->GetNextRuleId(), 
5238                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5239                     new System.Text.Parsing.GroupingParser(
5240                         new System.Text.Parsing.SequenceParser(
5241                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5242                                 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("LogicalAndExpression"), 1)), 
5243                             new System.Text.Parsing.KleeneStarParser(
5244                                 new System.Text.Parsing.GroupingParser(
5245                                     new System.Text.Parsing.SequenceParser(
5246                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5247                                             new System.Text.Parsing.StringParser(ToUtf32("||"))), 
5248                                         new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5249                                             new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("LogicalAndExpression"), 1))))))))));
5250             AddRule(new LogicalAndExpressionRule(ToUtf32("LogicalAndExpression"), GetScope(), Domain()->GetNextRuleId(), 
5251                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5252                     new System.Text.Parsing.GroupingParser(
5253                         new System.Text.Parsing.SequenceParser(
5254                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5255                                 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("InclusiveOrExpression"), 1)), 
5256                             new System.Text.Parsing.KleeneStarParser(
5257                                 new System.Text.Parsing.GroupingParser(
5258                                     new System.Text.Parsing.SequenceParser(
5259                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5260                                             new System.Text.Parsing.StringParser(ToUtf32("&&"))), 
5261                                         new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5262                                             new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("InclusiveOrExpression"), 1))))))))));
5263             AddRule(new InclusiveOrExpressionRule(ToUtf32("InclusiveOrExpression"), GetScope(), Domain()->GetNextRuleId(), 
5264                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5265                     new System.Text.Parsing.GroupingParser(
5266                         new System.Text.Parsing.SequenceParser(
5267                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5268                                 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("ExclusiveOrExpression"), 1)), 
5269                             new System.Text.Parsing.KleeneStarParser(
5270                                 new System.Text.Parsing.GroupingParser(
5271                                     new System.Text.Parsing.SequenceParser(
5272                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5273                                             new System.Text.Parsing.GroupingParser(
5274                                                 new System.Text.Parsing.DifferenceParser(
5275                                                     new System.Text.Parsing.CharParser('|'), 
5276                                                     new System.Text.Parsing.GroupingParser(
5277                                                         new System.Text.Parsing.AlternativeParser(
5278                                                             new System.Text.Parsing.StringParser(ToUtf32("|=")), 
5279                                                             new System.Text.Parsing.StringParser(ToUtf32("||"))))))), 
5280                                         new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5281                                             new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("ExclusiveOrExpression"), 1))))))))));
5282             AddRule(new ExclusiveOrExpressionRule(ToUtf32("ExclusiveOrExpression"), GetScope(), Domain()->GetNextRuleId(), 
5283                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5284                     new System.Text.Parsing.GroupingParser(
5285                         new System.Text.Parsing.SequenceParser(
5286                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5287                                 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("AndExpression"), 1)), 
5288                             new System.Text.Parsing.KleeneStarParser(
5289                                 new System.Text.Parsing.GroupingParser(
5290                                     new System.Text.Parsing.SequenceParser(
5291                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5292                                             new System.Text.Parsing.GroupingParser(
5293                                                 new System.Text.Parsing.DifferenceParser(
5294                                                     new System.Text.Parsing.CharParser('^'), 
5295                                                     new System.Text.Parsing.StringParser(ToUtf32("^="))))), 
5296                                         new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5297                                             new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("AndExpression"), 1))))))))));
5298             AddRule(new AndExpressionRule(ToUtf32("AndExpression"), GetScope(), Domain()->GetNextRuleId(), 
5299                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5300                     new System.Text.Parsing.GroupingParser(
5301                         new System.Text.Parsing.SequenceParser(
5302                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5303                                 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("EqualityExpression"), 1)), 
5304                             new System.Text.Parsing.KleeneStarParser(
5305                                 new System.Text.Parsing.GroupingParser(
5306                                     new System.Text.Parsing.SequenceParser(
5307                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5308                                             new System.Text.Parsing.GroupingParser(
5309                                                 new System.Text.Parsing.DifferenceParser(
5310                                                     new System.Text.Parsing.CharParser('&'), 
5311                                                     new System.Text.Parsing.GroupingParser(
5312                                                         new System.Text.Parsing.AlternativeParser(
5313                                                             new System.Text.Parsing.StringParser(ToUtf32("&=")), 
5314                                                             new System.Text.Parsing.StringParser(ToUtf32("&&"))))))), 
5315                                         new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5316                                             new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("EqualityExpression"), 1))))))))));
5317             AddRule(new EqualityExpressionRule(ToUtf32("EqualityExpression"), GetScope(), Domain()->GetNextRuleId(), 
5318                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5319                     new System.Text.Parsing.GroupingParser(
5320                         new System.Text.Parsing.SequenceParser(
5321                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5322                                 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("RelationalExpression"), 1)), 
5323                             new System.Text.Parsing.KleeneStarParser(
5324                                 new System.Text.Parsing.GroupingParser(
5325                                     new System.Text.Parsing.SequenceParser(
5326                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5327                                             new System.Text.Parsing.GroupingParser(
5328                                                 new System.Text.Parsing.AlternativeParser(
5329                                                     new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5330                                                         new System.Text.Parsing.StringParser(ToUtf32("=="))), 
5331                                                     new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5332                                                         new System.Text.Parsing.StringParser(ToUtf32("!=")))))), 
5333                                         new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
5334                                             new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("RelationalExpression"), 1))))))))));
5335             AddRule(new RelationalExpressionRule(ToUtf32("RelationalExpression"), GetScope(), Domain()->GetNextRuleId(), 
5336                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5337                     new System.Text.Parsing.GroupingParser(
5338                         new System.Text.Parsing.SequenceParser(
5339                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5340                                 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("ShiftExpression"), 1)), 
5341                             new System.Text.Parsing.KleeneStarParser(
5342                                 new System.Text.Parsing.GroupingParser(
5343                                     new System.Text.Parsing.SequenceParser(
5344                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5345                                             new System.Text.Parsing.GroupingParser(
5346                                                 new System.Text.Parsing.AlternativeParser(
5347                                                     new System.Text.Parsing.AlternativeParser(
5348                                                         new System.Text.Parsing.AlternativeParser(
5349                                                             new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5350                                                                 new System.Text.Parsing.StringParser(ToUtf32("<="))), 
5351                                                             new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5352                                                                 new System.Text.Parsing.StringParser(ToUtf32(">=")))), 
5353                                                         new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
5354                                                             new System.Text.Parsing.GroupingParser(
5355                                                                 new System.Text.Parsing.DifferenceParser(
5356                                                                     new System.Text.Parsing.CharParser('<'), 
5357                                                                     new System.Text.Parsing.GroupingParser(
5358                                                                         new System.Text.Parsing.AlternativeParser(
5359                                                                             new System.Text.Parsing.StringParser(ToUtf32("<<")), 
5360                                                                             new System.Text.Parsing.StringParser(ToUtf32("<<=")))))))), 
5361                                                     new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
5362                                                         new System.Text.Parsing.GroupingParser(
5363                                                             new System.Text.Parsing.DifferenceParser(
5364                                                                 new System.Text.Parsing.CharParser('>'), 
5365                                                                 new System.Text.Parsing.GroupingParser(
5366                                                                     new System.Text.Parsing.AlternativeParser(
5367                                                                         new System.Text.Parsing.StringParser(ToUtf32(">>")), 
5368                                                                         new System.Text.Parsing.StringParser(ToUtf32(">>=")))))))))), 
5369                                         new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
5370                                             new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("ShiftExpression"), 1))))))))));
5371             AddRule(new ShiftExpressionRule(ToUtf32("ShiftExpression"), GetScope(), Domain()->GetNextRuleId(), 
5372                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5373                     new System.Text.Parsing.GroupingParser(
5374                         new System.Text.Parsing.SequenceParser(
5375                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5376                                 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("AdditiveExpression"), 1)), 
5377                             new System.Text.Parsing.KleeneStarParser(
5378                                 new System.Text.Parsing.GroupingParser(
5379                                     new System.Text.Parsing.SequenceParser(
5380                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5381                                             new System.Text.Parsing.GroupingParser(
5382                                                 new System.Text.Parsing.AlternativeParser(
5383                                                     new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5384                                                         new System.Text.Parsing.GroupingParser(
5385                                                             new System.Text.Parsing.DifferenceParser(
5386                                                                 new System.Text.Parsing.StringParser(ToUtf32("<<")), 
5387                                                                 new System.Text.Parsing.StringParser(ToUtf32("<<="))))), 
5388                                                     new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5389                                                         new System.Text.Parsing.GroupingParser(
5390                                                             new System.Text.Parsing.DifferenceParser(
5391                                                                 new System.Text.Parsing.StringParser(ToUtf32(">>")), 
5392                                                                 new System.Text.Parsing.StringParser(ToUtf32(">>=")))))))), 
5393                                         new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
5394                                             new System.Text.Parsing.GroupingParser(
5395                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("AdditiveExpression"), 1)))))))))));
5396             AddRule(new AdditiveExpressionRule(ToUtf32("AdditiveExpression"), GetScope(), Domain()->GetNextRuleId(), 
5397                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5398                     new System.Text.Parsing.GroupingParser(
5399                         new System.Text.Parsing.SequenceParser(
5400                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5401                                 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("MultiplicativeExpression"), 1)), 
5402                             new System.Text.Parsing.KleeneStarParser(
5403                                 new System.Text.Parsing.GroupingParser(
5404                                     new System.Text.Parsing.SequenceParser(
5405                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5406                                             new System.Text.Parsing.GroupingParser(
5407                                                 new System.Text.Parsing.AlternativeParser(
5408                                                     new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5409                                                         new System.Text.Parsing.GroupingParser(
5410                                                             new System.Text.Parsing.DifferenceParser(
5411                                                                 new System.Text.Parsing.CharParser('+'), 
5412                                                                 new System.Text.Parsing.StringParser(ToUtf32("+="))))), 
5413                                                     new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5414                                                         new System.Text.Parsing.GroupingParser(
5415                                                             new System.Text.Parsing.DifferenceParser(
5416                                                                 new System.Text.Parsing.CharParser('-'), 
5417                                                                 new System.Text.Parsing.StringParser(ToUtf32("-=")))))))), 
5418                                         new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
5419                                             new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("MultiplicativeExpression"), 1))))))))));
5420             AddRule(new MultiplicativeExpressionRule(ToUtf32("MultiplicativeExpression"), GetScope(), Domain()->GetNextRuleId(), 
5421                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5422                     new System.Text.Parsing.GroupingParser(
5423                         new System.Text.Parsing.SequenceParser(
5424                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5425                                 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("PMExpression"), 1)), 
5426                             new System.Text.Parsing.KleeneStarParser(
5427                                 new System.Text.Parsing.GroupingParser(
5428                                     new System.Text.Parsing.SequenceParser(
5429                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5430                                             new System.Text.Parsing.GroupingParser(
5431                                                 new System.Text.Parsing.AlternativeParser(
5432                                                     new System.Text.Parsing.AlternativeParser(
5433                                                         new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5434                                                             new System.Text.Parsing.GroupingParser(
5435                                                                 new System.Text.Parsing.DifferenceParser(
5436                                                                     new System.Text.Parsing.CharParser('*'), 
5437                                                                     new System.Text.Parsing.StringParser(ToUtf32("*="))))), 
5438                                                         new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5439                                                             new System.Text.Parsing.GroupingParser(
5440                                                                 new System.Text.Parsing.DifferenceParser(
5441                                                                     new System.Text.Parsing.CharParser('/'), 
5442                                                                     new System.Text.Parsing.StringParser(ToUtf32("/=")))))), 
5443                                                     new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
5444                                                         new System.Text.Parsing.GroupingParser(
5445                                                             new System.Text.Parsing.DifferenceParser(
5446                                                                 new System.Text.Parsing.CharParser('%'), 
5447                                                                 new System.Text.Parsing.StringParser(ToUtf32("%=")))))))), 
5448                                         new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
5449                                             new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("PMExpression"), 1))))))))));
5450             AddRule(new PMExpressionRule(ToUtf32("PMExpression"), GetScope(), Domain()->GetNextRuleId(), 
5451                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5452                     new System.Text.Parsing.GroupingParser(
5453                         new System.Text.Parsing.SequenceParser(
5454                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5455                                 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("CastExpression"), 1)), 
5456                             new System.Text.Parsing.KleeneStarParser(
5457                                 new System.Text.Parsing.GroupingParser(
5458                                     new System.Text.Parsing.SequenceParser(
5459                                         new System.Text.Parsing.GroupingParser(
5460                                             new System.Text.Parsing.AlternativeParser(
5461                                                 new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5462                                                     new System.Text.Parsing.StringParser(ToUtf32(".*"))), 
5463                                                 new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5464                                                     new System.Text.Parsing.StringParser(ToUtf32("->*"))))), 
5465                                         new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5466                                             new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("CastExpression"), 1))))))))));
5467             AddRule(new CastExpressionRule(ToUtf32("CastExpression"), GetScope(), Domain()->GetNextRuleId(), 
5468                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5469                     new System.Text.Parsing.GroupingParser(
5470                         new System.Text.Parsing.AlternativeParser(
5471                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5472                                 new System.Text.Parsing.GroupingParser(
5473                                     new System.Text.Parsing.SequenceParser(
5474                                         new System.Text.Parsing.SequenceParser(
5475                                             new System.Text.Parsing.SequenceParser(
5476                                                 new System.Text.Parsing.CharParser('('), 
5477                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("TypeExpr"), ToUtf32("TypeExpr"), 1)), 
5478                                             new System.Text.Parsing.CharParser(')')), 
5479                                         new System.Text.Parsing.NonterminalParser(ToUtf32("CastExpression"), ToUtf32("CastExpression"), 1)))), 
5480                             new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5481                                 new System.Text.Parsing.NonterminalParser(ToUtf32("UnaryExpression"), ToUtf32("UnaryExpression"), 1)))))));
5482             AddRule(new UnaryExpressionRule(ToUtf32("UnaryExpression"), GetScope(), Domain()->GetNextRuleId(), 
5483                 new System.Text.Parsing.AlternativeParser(
5484                     new System.Text.Parsing.AlternativeParser(
5485                         new System.Text.Parsing.AlternativeParser(
5486                             new System.Text.Parsing.AlternativeParser(
5487                                 new System.Text.Parsing.AlternativeParser(
5488                                     new System.Text.Parsing.AlternativeParser(
5489                                         new System.Text.Parsing.AlternativeParser(
5490                                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5491                                                 new System.Text.Parsing.GroupingParser(
5492                                                     new System.Text.Parsing.SequenceParser(
5493                                                         new System.Text.Parsing.StringParser(ToUtf32("++")), 
5494                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("c1"), ToUtf32("CastExpression"), 1)))), 
5495                                             new System.Text.Parsing.SequenceParser(
5496                                                 new System.Text.Parsing.StringParser(ToUtf32("--")), 
5497                                                 new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5498                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("c2"), ToUtf32("CastExpression"), 1)))), 
5499                                         new System.Text.Parsing.SequenceParser(
5500                                             new System.Text.Parsing.NonterminalParser(ToUtf32("op"), ToUtf32("UnaryOperator"), 0), 
5501                                             new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5502                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("c3"), ToUtf32("CastExpression"), 1)))), 
5503                                     new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5504                                         new System.Text.Parsing.GroupingParser(
5505                                             new System.Text.Parsing.SequenceParser(
5506                                                 new System.Text.Parsing.KeywordParser(ToUtf32("sizeof")), 
5507                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("u4"), ToUtf32("UnaryExpression"), 1))))), 
5508                                 new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5509                                     new System.Text.Parsing.GroupingParser(
5510                                         new System.Text.Parsing.SequenceParser(
5511                                             new System.Text.Parsing.SequenceParser(
5512                                                 new System.Text.Parsing.SequenceParser(
5513                                                     new System.Text.Parsing.KeywordParser(ToUtf32("alignof")), 
5514                                                     new System.Text.Parsing.CharParser('(')), 
5515                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("t5"), ToUtf32("TypeExpr"), 1)), 
5516                                             new System.Text.Parsing.CharParser(')'))))), 
5517                             new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
5518                                 new System.Text.Parsing.NonterminalParser(ToUtf32("NewExpression"), ToUtf32("NewExpression"), 1))), 
5519                         new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
5520                             new System.Text.Parsing.NonterminalParser(ToUtf32("DeleteExpression"), ToUtf32("DeleteExpression"), 1))), 
5521                     new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
5522                         new System.Text.Parsing.NonterminalParser(ToUtf32("PostfixExpression"), ToUtf32("PostfixExpression"), 1)))));
5523             AddRule(new UnaryOperatorRule(ToUtf32("UnaryOperator"), GetScope(), Domain()->GetNextRuleId(), 
5524                 new System.Text.Parsing.AlternativeParser(
5525                     new System.Text.Parsing.AlternativeParser(
5526                         new System.Text.Parsing.AlternativeParser(
5527                             new System.Text.Parsing.AlternativeParser(
5528                                 new System.Text.Parsing.AlternativeParser(
5529                                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5530                                         new System.Text.Parsing.GroupingParser(
5531                                             new System.Text.Parsing.DifferenceParser(
5532                                                 new System.Text.Parsing.CharParser('*'), 
5533                                                 new System.Text.Parsing.StringParser(ToUtf32("*="))))), 
5534                                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5535                                         new System.Text.Parsing.GroupingParser(
5536                                             new System.Text.Parsing.DifferenceParser(
5537                                                 new System.Text.Parsing.CharParser('&'), 
5538                                                 new System.Text.Parsing.StringParser(ToUtf32("&=")))))), 
5539                                 new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5540                                     new System.Text.Parsing.GroupingParser(
5541                                         new System.Text.Parsing.DifferenceParser(
5542                                             new System.Text.Parsing.CharParser('+'), 
5543                                             new System.Text.Parsing.StringParser(ToUtf32("+=")))))), 
5544                             new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5545                                 new System.Text.Parsing.GroupingParser(
5546                                     new System.Text.Parsing.DifferenceParser(
5547                                         new System.Text.Parsing.CharParser('-'), 
5548                                         new System.Text.Parsing.StringParser(ToUtf32("-=")))))), 
5549                         new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5550                             new System.Text.Parsing.CharParser('!'))), 
5551                     new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
5552                         new System.Text.Parsing.CharParser('~')))));
5553             AddRule(new NewExpressionRule(ToUtf32("NewExpression"), GetScope(), Domain()->GetNextRuleId(), 
5554                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5555                     new System.Text.Parsing.GroupingParser(
5556                         new System.Text.Parsing.SequenceParser(
5557                             new System.Text.Parsing.SequenceParser(
5558                                 new System.Text.Parsing.SequenceParser(
5559                                     new System.Text.Parsing.KeywordParser(ToUtf32("new")), 
5560                                     new System.Text.Parsing.OptionalParser(
5561                                         new System.Text.Parsing.NonterminalParser(ToUtf32("NewPlacement"), ToUtf32("NewPlacement"), 1))), 
5562                                 new System.Text.Parsing.NonterminalParser(ToUtf32("NewTypeId"), ToUtf32("NewTypeId"), 1)), 
5563                             new System.Text.Parsing.OptionalParser(
5564                                 new System.Text.Parsing.NonterminalParser(ToUtf32("NewInitializer"), ToUtf32("NewInitializer"), 1)))))));
5565             AddRule(new NewPlacementRule(ToUtf32("NewPlacement"), GetScope(), Domain()->GetNextRuleId(), 
5566                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5567                     new System.Text.Parsing.GroupingParser(
5568                         new System.Text.Parsing.SequenceParser(
5569                             new System.Text.Parsing.SequenceParser(
5570                                 new System.Text.Parsing.CharParser('('), 
5571                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ExpressionList"), ToUtf32("ExpressionList"), 1)), 
5572                             new System.Text.Parsing.CharParser(')'))))));
5573             AddRule(new NewTypeIdRule(ToUtf32("NewTypeId"), GetScope(), Domain()->GetNextRuleId(), 
5574                 new System.Text.Parsing.SequenceParser(
5575                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5576                         new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1)), 
5577                     new System.Text.Parsing.OptionalParser(
5578                         new System.Text.Parsing.GroupingParser(
5579                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5580                                 new System.Text.Parsing.NonterminalParser(ToUtf32("size"), ToUtf32("NewDeclarator"), 1)))))));
5581             AddRule(new NewDeclaratorRule(ToUtf32("NewDeclarator"), GetScope(), Domain()->GetNextRuleId(), 
5582                 new System.Text.Parsing.SequenceParser(
5583                     new System.Text.Parsing.SequenceParser(
5584                         new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5585                             new System.Text.Parsing.CharParser('[')), 
5586                         new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5587                             new System.Text.Parsing.NonterminalParser(ToUtf32("size"), ToUtf32("Expression"), 1))), 
5588                     new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5589                         new System.Text.Parsing.CharParser(']')))));
5590             AddRule(new NewInitializerRule(ToUtf32("NewInitializer"), GetScope(), Domain()->GetNextRuleId(), 
5591                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5592                     new System.Text.Parsing.GroupingParser(
5593                         new System.Text.Parsing.SequenceParser(
5594                             new System.Text.Parsing.SequenceParser(
5595                                 new System.Text.Parsing.CharParser('('), 
5596                                 new System.Text.Parsing.NonterminalParser(ToUtf32("args"), ToUtf32("PossiblyEmptyArgumentList"), 1)), 
5597                             new System.Text.Parsing.CharParser(')'))))));
5598             AddRule(new DeleteExpressionRule(ToUtf32("DeleteExpression"), GetScope(), Domain()->GetNextRuleId(), 
5599                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5600                     new System.Text.Parsing.GroupingParser(
5601                         new System.Text.Parsing.SequenceParser(
5602                             new System.Text.Parsing.SequenceParser(
5603                                 new System.Text.Parsing.KeywordParser(ToUtf32("delete")), 
5604                                 new System.Text.Parsing.OptionalParser(
5605                                     new System.Text.Parsing.GroupingParser(
5606                                         new System.Text.Parsing.SequenceParser(
5607                                             new System.Text.Parsing.CharParser('['), 
5608                                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5609                                                 new System.Text.Parsing.CharParser(']')))))), 
5610                             new System.Text.Parsing.NonterminalParser(ToUtf32("CastExpression"), ToUtf32("CastExpression"), 1))))));
5611             AddRule(new PostfixExpressionRule(ToUtf32("PostfixExpression"), GetScope(), Domain()->GetNextRuleId(), 
5612                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5613                     new System.Text.Parsing.GroupingParser(
5614                         new System.Text.Parsing.SequenceParser(
5615                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5616                                 new System.Text.Parsing.NonterminalParser(ToUtf32("PrimaryExpression"), ToUtf32("PrimaryExpression"), 1)), 
5617                             new System.Text.Parsing.KleeneStarParser(
5618                                 new System.Text.Parsing.GroupingParser(
5619                                     new System.Text.Parsing.AlternativeParser(
5620                                         new System.Text.Parsing.AlternativeParser(
5621                                             new System.Text.Parsing.AlternativeParser(
5622                                                 new System.Text.Parsing.AlternativeParser(
5623                                                     new System.Text.Parsing.AlternativeParser(
5624                                                         new System.Text.Parsing.SequenceParser(
5625                                                             new System.Text.Parsing.SequenceParser(
5626                                                                 new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5627                                                                     new System.Text.Parsing.CharParser('[')), 
5628                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("subscript"), ToUtf32("Expression"), 1)), 
5629                                                             new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5630                                                                 new System.Text.Parsing.CharParser(']'))), 
5631                                                         new System.Text.Parsing.SequenceParser(
5632                                                             new System.Text.Parsing.SequenceParser(
5633                                                                 new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5634                                                                     new System.Text.Parsing.CharParser('(')), 
5635                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arguments"), ToUtf32("PossiblyEmptyArgumentList"), 1)), 
5636                                                             new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
5637                                                                 new System.Text.Parsing.CharParser(')')))), 
5638                                                     new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
5639                                                         new System.Text.Parsing.GroupingParser(
5640                                                             new System.Text.Parsing.SequenceParser(
5641                                                                 new System.Text.Parsing.GroupingParser(
5642                                                                     new System.Text.Parsing.DifferenceParser(
5643                                                                         new System.Text.Parsing.CharParser('.'), 
5644                                                                         new System.Text.Parsing.StringParser(ToUtf32(".*")))), 
5645                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("id1"), ToUtf32("IdExpression"), 1))))), 
5646                                                 new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
5647                                                     new System.Text.Parsing.GroupingParser(
5648                                                         new System.Text.Parsing.SequenceParser(
5649                                                             new System.Text.Parsing.GroupingParser(
5650                                                                 new System.Text.Parsing.DifferenceParser(
5651                                                                     new System.Text.Parsing.StringParser(ToUtf32("->")), 
5652                                                                     new System.Text.Parsing.StringParser(ToUtf32("->*")))), 
5653                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("id2"), ToUtf32("IdExpression"), 1))))), 
5654                                             new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
5655                                                 new System.Text.Parsing.StringParser(ToUtf32("++")))), 
5656                                         new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
5657                                             new System.Text.Parsing.StringParser(ToUtf32("--")))))))))));
5658             AddRule(new PrimaryExpressionRule(ToUtf32("PrimaryExpression"), GetScope(), Domain()->GetNextRuleId(), 
5659                 new System.Text.Parsing.AlternativeParser(
5660                     new System.Text.Parsing.AlternativeParser(
5661                         new System.Text.Parsing.AlternativeParser(
5662                             new System.Text.Parsing.AlternativeParser(
5663                                 new System.Text.Parsing.AlternativeParser(
5664                                     new System.Text.Parsing.AlternativeParser(
5665                                         new System.Text.Parsing.AlternativeParser(
5666                                             new System.Text.Parsing.AlternativeParser(
5667                                                 new System.Text.Parsing.AlternativeParser(
5668                                                     new System.Text.Parsing.AlternativeParser(
5669                                                         new System.Text.Parsing.AlternativeParser(
5670                                                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5671                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("Literal"), ToUtf32("Literal"), 0)), 
5672                                                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5673                                                                 new System.Text.Parsing.KeywordParser(ToUtf32("this")))), 
5674                                                         new System.Text.Parsing.SequenceParser(
5675                                                             new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5676                                                                 new System.Text.Parsing.EmptyParser()), 
5677                                                             new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5678                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("DefinedExpr"), ToUtf32("DefinedExpr"), 0)))), 
5679                                                     new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5680                                                         new System.Text.Parsing.GroupingParser(
5681                                                             new System.Text.Parsing.SequenceParser(
5682                                                                 new System.Text.Parsing.SequenceParser(
5683                                                                     new System.Text.Parsing.CharParser('('), 
5684                                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("expr"), ToUtf32("Expression"), 1)), 
5685                                                                 new System.Text.Parsing.CharParser(')'))))), 
5686                                                 new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
5687                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("CppCastExpression"), ToUtf32("CppCastExpression"), 1))), 
5688                                             new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
5689                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("TypeIdExpression"), ToUtf32("TypeIdExpression"), 1))), 
5690                                         new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
5691                                             new System.Text.Parsing.GroupingParser(
5692                                                 new System.Text.Parsing.SequenceParser(
5693                                                     new System.Text.Parsing.SequenceParser(
5694                                                         new System.Text.Parsing.SequenceParser(
5695                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("s1"), ToUtf32("SimpleTypeSpecifier"), 0), 
5696                                                             new System.Text.Parsing.CharParser('(')), 
5697                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("args1"), ToUtf32("PossiblyEmptyArgumentList"), 1)), 
5698                                                     new System.Text.Parsing.CharParser(')'))))), 
5699                                     new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
5700                                         new System.Text.Parsing.GroupingParser(
5701                                             new System.Text.Parsing.SequenceParser(
5702                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("s2"), ToUtf32("SimpleTypeSpecifier"), 0), 
5703                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("b1"), ToUtf32("BracedInitializerList"), 1))))), 
5704                                 new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
5705                                     new System.Text.Parsing.GroupingParser(
5706                                         new System.Text.Parsing.SequenceParser(
5707                                             new System.Text.Parsing.SequenceParser(
5708                                                 new System.Text.Parsing.SequenceParser(
5709                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("t1"), ToUtf32("TypeExpr"), 1), 
5710                                                     new System.Text.Parsing.CharParser('(')), 
5711                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("args2"), ToUtf32("PossiblyEmptyArgumentList"), 1)), 
5712                                             new System.Text.Parsing.CharParser(')'))))), 
5713                             new System.Text.Parsing.ActionParser(ToUtf32("A10"), 
5714                                 new System.Text.Parsing.GroupingParser(
5715                                     new System.Text.Parsing.SequenceParser(
5716                                         new System.Text.Parsing.NonterminalParser(ToUtf32("t2"), ToUtf32("TypeExpr"), 1), 
5717                                         new System.Text.Parsing.NonterminalParser(ToUtf32("b2"), ToUtf32("BracedInitializerList"), 1))))), 
5718                         new System.Text.Parsing.ActionParser(ToUtf32("A11"), 
5719                             new System.Text.Parsing.NonterminalParser(ToUtf32("IdExpression"), ToUtf32("IdExpression"), 1))), 
5720                     new System.Text.Parsing.ActionParser(ToUtf32("A12"), 
5721                         new System.Text.Parsing.NonterminalParser(ToUtf32("LambdaExpression"), ToUtf32("LambdaExpression"), 1)))));
5722             AddRule(new CppCastExpressionRule(ToUtf32("CppCastExpression"), GetScope(), Domain()->GetNextRuleId(), 
5723                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5724                     new System.Text.Parsing.GroupingParser(
5725                         new System.Text.Parsing.SequenceParser(
5726                             new System.Text.Parsing.SequenceParser(
5727                                 new System.Text.Parsing.SequenceParser(
5728                                     new System.Text.Parsing.SequenceParser(
5729                                         new System.Text.Parsing.SequenceParser(
5730                                             new System.Text.Parsing.SequenceParser(
5731                                                 new System.Text.Parsing.GroupingParser(
5732                                                     new System.Text.Parsing.AlternativeParser(
5733                                                         new System.Text.Parsing.AlternativeParser(
5734                                                             new System.Text.Parsing.AlternativeParser(
5735                                                                 new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5736                                                                     new System.Text.Parsing.KeywordParser(ToUtf32("dynamic_cast"))), 
5737                                                                 new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5738                                                                     new System.Text.Parsing.KeywordParser(ToUtf32("static_cast")))), 
5739                                                             new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5740                                                                 new System.Text.Parsing.KeywordParser(ToUtf32("reinterpret_cast")))), 
5741                                                         new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5742                                                             new System.Text.Parsing.KeywordParser(ToUtf32("const_cast"))))), 
5743                                                 new System.Text.Parsing.CharParser('<')), 
5744                                             new System.Text.Parsing.NonterminalParser(ToUtf32("t1"), ToUtf32("TypeExpr"), 1)), 
5745                                         new System.Text.Parsing.CharParser('>')), 
5746                                     new System.Text.Parsing.CharParser('(')), 
5747                                 new System.Text.Parsing.NonterminalParser(ToUtf32("e1"), ToUtf32("Expression"), 1)), 
5748                             new System.Text.Parsing.CharParser(')'))))));
5749             AddRule(new DefinedExprRule(ToUtf32("DefinedExpr"), GetScope(), Domain()->GetNextRuleId(), 
5750                 new System.Text.Parsing.AlternativeParser(
5751                     new System.Text.Parsing.AlternativeParser(
5752                         new System.Text.Parsing.AlternativeParser(
5753                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5754                                 new System.Text.Parsing.GroupingParser(
5755                                     new System.Text.Parsing.SequenceParser(
5756                                         new System.Text.Parsing.SequenceParser(
5757                                             new System.Text.Parsing.SequenceParser(
5758                                                 new System.Text.Parsing.KeywordParser(ToUtf32("defined")), 
5759                                                 new System.Text.Parsing.CharParser('(')), 
5760                                             new System.Text.Parsing.NonterminalParser(ToUtf32("id1"), ToUtf32("identifier"), 0)), 
5761                                         new System.Text.Parsing.CharParser(')')))), 
5762                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5763                                 new System.Text.Parsing.GroupingParser(
5764                                     new System.Text.Parsing.SequenceParser(
5765                                         new System.Text.Parsing.KeywordParser(ToUtf32("defined")), 
5766                                         new System.Text.Parsing.NonterminalParser(ToUtf32("id2"), ToUtf32("identifier"), 0))))), 
5767                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5768                             new System.Text.Parsing.GroupingParser(
5769                                 new System.Text.Parsing.SequenceParser(
5770                                     new System.Text.Parsing.SequenceParser(
5771                                         new System.Text.Parsing.SequenceParser(
5772                                             new System.Text.Parsing.KeywordParser(ToUtf32("defined")), 
5773                                             new System.Text.Parsing.CharParser('(')), 
5774                                         new System.Text.Parsing.NonterminalParser(ToUtf32("lit1"), ToUtf32("Literal"), 0)), 
5775                                     new System.Text.Parsing.CharParser(')'))))), 
5776                     new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5777                         new System.Text.Parsing.GroupingParser(
5778                             new System.Text.Parsing.SequenceParser(
5779                                 new System.Text.Parsing.KeywordParser(ToUtf32("defined")), 
5780                                 new System.Text.Parsing.NonterminalParser(ToUtf32("lit2"), ToUtf32("Literal"), 0)))))));
5781             AddRule(new TypeIdExpressionRule(ToUtf32("TypeIdExpression"), GetScope(), Domain()->GetNextRuleId(), 
5782                 new System.Text.Parsing.AlternativeParser(
5783                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5784                         new System.Text.Parsing.GroupingParser(
5785                             new System.Text.Parsing.SequenceParser(
5786                                 new System.Text.Parsing.SequenceParser(
5787                                     new System.Text.Parsing.SequenceParser(
5788                                         new System.Text.Parsing.KeywordParser(ToUtf32("typeid")), 
5789                                         new System.Text.Parsing.CharParser('(')), 
5790                                     new System.Text.Parsing.NonterminalParser(ToUtf32("t1"), ToUtf32("TypeExpr"), 1)), 
5791                                 new System.Text.Parsing.CharParser(')')))), 
5792                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5793                         new System.Text.Parsing.GroupingParser(
5794                             new System.Text.Parsing.SequenceParser(
5795                                 new System.Text.Parsing.SequenceParser(
5796                                     new System.Text.Parsing.SequenceParser(
5797                                         new System.Text.Parsing.KeywordParser(ToUtf32("typeid")), 
5798                                         new System.Text.Parsing.CharParser('(')), 
5799                                     new System.Text.Parsing.NonterminalParser(ToUtf32("e1"), ToUtf32("Expression"), 1)), 
5800                                 new System.Text.Parsing.CharParser(')')))))));
5801             AddRule(new IdExpressionRule(ToUtf32("IdExpression"), GetScope(), Domain()->GetNextRuleId(), 
5802                 new System.Text.Parsing.AlternativeParser(
5803                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5804                         new System.Text.Parsing.NonterminalParser(ToUtf32("QualifiedIdExpr"), ToUtf32("QualifiedIdExpr"), 1)), 
5805                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5806                         new System.Text.Parsing.NonterminalParser(ToUtf32("UnqualifiedIdExpr"), ToUtf32("UnqualifiedIdExpr"), 1)))));
5807             AddRule(new UnqualifiedIdExprRule(ToUtf32("UnqualifiedIdExpr"), GetScope(), Domain()->GetNextRuleId(), 
5808                 new System.Text.Parsing.AlternativeParser(
5809                     new System.Text.Parsing.AlternativeParser(
5810                         new System.Text.Parsing.AlternativeParser(
5811                             new System.Text.Parsing.AlternativeParser(
5812                                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5813                                     new System.Text.Parsing.NonterminalParser(ToUtf32("TemplateId"), ToUtf32("TemplateId"), 1)), 
5814                                 new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5815                                     new System.Text.Parsing.NonterminalParser(ToUtf32("id1"), ToUtf32("Identifier"), 0))), 
5816                             new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5817                                 new System.Text.Parsing.NonterminalParser(ToUtf32("OperatorFunctionId"), ToUtf32("OperatorFunctionId"), 0))), 
5818                         new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5819                             new System.Text.Parsing.NonterminalParser(ToUtf32("ConversionFunctionId"), ToUtf32("ConversionFunctionId"), 1))), 
5820                     new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5821                         new System.Text.Parsing.GroupingParser(
5822                             new System.Text.Parsing.SequenceParser(
5823                                 new System.Text.Parsing.CharParser('~'), 
5824                                 new System.Text.Parsing.NonterminalParser(ToUtf32("id2"), ToUtf32("Identifier"), 0)))))));
5825             AddRule(new QualifiedIdExprRule(ToUtf32("QualifiedIdExpr"), GetScope(), Domain()->GetNextRuleId(), 
5826                 new System.Text.Parsing.AlternativeParser(
5827                     new System.Text.Parsing.AlternativeParser(
5828                         new System.Text.Parsing.AlternativeParser(
5829                             new System.Text.Parsing.AlternativeParser(
5830                                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5831                                     new System.Text.Parsing.GroupingParser(
5832                                         new System.Text.Parsing.SequenceParser(
5833                                             new System.Text.Parsing.StringParser(ToUtf32("::")), 
5834                                             new System.Text.Parsing.NonterminalParser(ToUtf32("TemplateId"), ToUtf32("TemplateId"), 1)))), 
5835                                 new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5836                                     new System.Text.Parsing.GroupingParser(
5837                                         new System.Text.Parsing.SequenceParser(
5838                                             new System.Text.Parsing.SequenceParser(
5839                                                 new System.Text.Parsing.StringParser(ToUtf32("::")), 
5840                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ns"), ToUtf32("NestedNameSpecifier"), 1)), 
5841                                             new System.Text.Parsing.NonterminalParser(ToUtf32("ud1"), ToUtf32("UnqualifiedIdExpr"), 1))))), 
5842                             new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5843                                 new System.Text.Parsing.GroupingParser(
5844                                     new System.Text.Parsing.SequenceParser(
5845                                         new System.Text.Parsing.StringParser(ToUtf32("::")), 
5846                                         new System.Text.Parsing.NonterminalParser(ToUtf32("Identifier"), ToUtf32("Identifier"), 0))))), 
5847                         new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5848                             new System.Text.Parsing.GroupingParser(
5849                                 new System.Text.Parsing.SequenceParser(
5850                                     new System.Text.Parsing.StringParser(ToUtf32("::")), 
5851                                     new System.Text.Parsing.NonterminalParser(ToUtf32("OperatorFunctionId"), ToUtf32("OperatorFunctionId"), 0))))), 
5852                     new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5853                         new System.Text.Parsing.GroupingParser(
5854                             new System.Text.Parsing.SequenceParser(
5855                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ns2"), ToUtf32("NestedNameSpecifier"), 1), 
5856                                 new System.Text.Parsing.NonterminalParser(ToUtf32("uid2"), ToUtf32("UnqualifiedIdExpr"), 1)))))));
5857             AddRule(new OperatorFunctionIdRule(ToUtf32("OperatorFunctionId"), GetScope(), Domain()->GetNextRuleId(), 
5858                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5859                     new System.Text.Parsing.GroupingParser(
5860                         new System.Text.Parsing.SequenceParser(
5861                             new System.Text.Parsing.KeywordParser(ToUtf32("operator")), 
5862                             new System.Text.Parsing.NonterminalParser(ToUtf32("Operator"), ToUtf32("Operator"), 0))))));
5863             AddRule(new OperatorRule(ToUtf32("Operator"), GetScope(), Domain()->GetNextRuleId(), 
5864                 new System.Text.Parsing.AlternativeParser(
5865                     new System.Text.Parsing.AlternativeParser(
5866                         new System.Text.Parsing.AlternativeParser(
5867                             new System.Text.Parsing.AlternativeParser(
5868                                 new System.Text.Parsing.AlternativeParser(
5869                                     new System.Text.Parsing.AlternativeParser(
5870                                         new System.Text.Parsing.AlternativeParser(
5871                                             new System.Text.Parsing.AlternativeParser(
5872                                                 new System.Text.Parsing.AlternativeParser(
5873                                                     new System.Text.Parsing.AlternativeParser(
5874                                                         new System.Text.Parsing.AlternativeParser(
5875                                                             new System.Text.Parsing.AlternativeParser(
5876                                                                 new System.Text.Parsing.AlternativeParser(
5877                                                                     new System.Text.Parsing.AlternativeParser(
5878                                                                         new System.Text.Parsing.AlternativeParser(
5879                                                                             new System.Text.Parsing.AlternativeParser(
5880                                                                                 new System.Text.Parsing.AlternativeParser(
5881                                                                                     new System.Text.Parsing.AlternativeParser(
5882                                                                                         new System.Text.Parsing.AlternativeParser(
5883                                                                                             new System.Text.Parsing.AlternativeParser(
5884                                                                                                 new System.Text.Parsing.AlternativeParser(
5885                                                                                                     new System.Text.Parsing.AlternativeParser(
5886                                                                                                         new System.Text.Parsing.AlternativeParser(
5887                                                                                                             new System.Text.Parsing.AlternativeParser(
5888                                                                                                                 new System.Text.Parsing.AlternativeParser(
5889                                                                                                                     new System.Text.Parsing.AlternativeParser(
5890                                                                                                                         new System.Text.Parsing.AlternativeParser(
5891                                                                                                                             new System.Text.Parsing.AlternativeParser(
5892                                                                                                                                 new System.Text.Parsing.AlternativeParser(
5893                                                                                                                                     new System.Text.Parsing.AlternativeParser(
5894                                                                                                                                         new System.Text.Parsing.AlternativeParser(
5895                                                                                                                                             new System.Text.Parsing.AlternativeParser(
5896                                                                                                                                                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5897                                                                                                                                                     new System.Text.Parsing.GroupingParser(
5898                                                                                                                                                         new System.Text.Parsing.SequenceParser(
5899                                                                                                                                                             new System.Text.Parsing.KeywordParser(ToUtf32("new")), 
5900                                                                                                                                                             new System.Text.Parsing.StringParser(ToUtf32("[]"))))), 
5901                                                                                                                                                 new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5902                                                                                                                                                     new System.Text.Parsing.GroupingParser(
5903                                                                                                                                                         new System.Text.Parsing.SequenceParser(
5904                                                                                                                                                             new System.Text.Parsing.KeywordParser(ToUtf32("delete")), 
5905                                                                                                                                                             new System.Text.Parsing.StringParser(ToUtf32("[]")))))), 
5906                                                                                                                                             new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5907                                                                                                                                                 new System.Text.Parsing.KeywordParser(ToUtf32("new")))), 
5908                                                                                                                                         new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
5909                                                                                                                                             new System.Text.Parsing.KeywordParser(ToUtf32("delete")))), 
5910                                                                                                                                     new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
5911                                                                                                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("AssignmentOperator"), ToUtf32("AssignmentOperator"), 0))), 
5912                                                                                                                                 new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
5913                                                                                                                                     new System.Text.Parsing.StringParser(ToUtf32("++")))), 
5914                                                                                                                             new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
5915                                                                                                                                 new System.Text.Parsing.StringParser(ToUtf32("--")))), 
5916                                                                                                                         new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
5917                                                                                                                             new System.Text.Parsing.StringParser(ToUtf32("<<")))), 
5918                                                                                                                     new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
5919                                                                                                                         new System.Text.Parsing.StringParser(ToUtf32(">>")))), 
5920                                                                                                                 new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
5921                                                                                                                     new System.Text.Parsing.StringParser(ToUtf32("&&")))), 
5922                                                                                                             new System.Text.Parsing.ActionParser(ToUtf32("A10"), 
5923                                                                                                                 new System.Text.Parsing.StringParser(ToUtf32("||")))), 
5924                                                                                                         new System.Text.Parsing.ActionParser(ToUtf32("A11"), 
5925                                                                                                             new System.Text.Parsing.StringParser(ToUtf32("==")))), 
5926                                                                                                     new System.Text.Parsing.ActionParser(ToUtf32("A12"), 
5927                                                                                                         new System.Text.Parsing.StringParser(ToUtf32("!=")))), 
5928                                                                                                 new System.Text.Parsing.ActionParser(ToUtf32("A13"), 
5929                                                                                                     new System.Text.Parsing.StringParser(ToUtf32("<=")))), 
5930                                                                                             new System.Text.Parsing.ActionParser(ToUtf32("A14"), 
5931                                                                                                 new System.Text.Parsing.StringParser(ToUtf32(">=")))), 
5932                                                                                         new System.Text.Parsing.ActionParser(ToUtf32("A15"), 
5933                                                                                             new System.Text.Parsing.StringParser(ToUtf32(".*")))), 
5934                                                                                     new System.Text.Parsing.ActionParser(ToUtf32("A16"), 
5935                                                                                         new System.Text.Parsing.StringParser(ToUtf32("->*")))), 
5936                                                                                 new System.Text.Parsing.ActionParser(ToUtf32("A17"), 
5937                                                                                     new System.Text.Parsing.StringParser(ToUtf32("->")))), 
5938                                                                             new System.Text.Parsing.ActionParser(ToUtf32("A18"), 
5939                                                                                 new System.Text.Parsing.StringParser(ToUtf32("()")))), 
5940                                                                         new System.Text.Parsing.ActionParser(ToUtf32("A19"), 
5941                                                                             new System.Text.Parsing.StringParser(ToUtf32("[]")))), 
5942                                                                     new System.Text.Parsing.ActionParser(ToUtf32("A20"), 
5943                                                                         new System.Text.Parsing.CharParser('<'))), 
5944                                                                 new System.Text.Parsing.ActionParser(ToUtf32("A21"), 
5945                                                                     new System.Text.Parsing.CharParser('>'))), 
5946                                                             new System.Text.Parsing.ActionParser(ToUtf32("A22"), 
5947                                                                 new System.Text.Parsing.CharParser('+'))), 
5948                                                         new System.Text.Parsing.ActionParser(ToUtf32("A23"), 
5949                                                             new System.Text.Parsing.CharParser('-'))), 
5950                                                     new System.Text.Parsing.ActionParser(ToUtf32("A24"), 
5951                                                         new System.Text.Parsing.CharParser('*'))), 
5952                                                 new System.Text.Parsing.ActionParser(ToUtf32("A25"), 
5953                                                     new System.Text.Parsing.CharParser('/'))), 
5954                                             new System.Text.Parsing.ActionParser(ToUtf32("A26"), 
5955                                                 new System.Text.Parsing.CharParser('%'))), 
5956                                         new System.Text.Parsing.ActionParser(ToUtf32("A27"), 
5957                                             new System.Text.Parsing.CharParser('^'))), 
5958                                     new System.Text.Parsing.ActionParser(ToUtf32("A28"), 
5959                                         new System.Text.Parsing.CharParser('&'))), 
5960                                 new System.Text.Parsing.ActionParser(ToUtf32("A29"), 
5961                                     new System.Text.Parsing.CharParser('|'))), 
5962                             new System.Text.Parsing.ActionParser(ToUtf32("A30"), 
5963                                 new System.Text.Parsing.CharParser('~'))), 
5964                         new System.Text.Parsing.ActionParser(ToUtf32("A31"), 
5965                             new System.Text.Parsing.CharParser('!'))), 
5966                     new System.Text.Parsing.ActionParser(ToUtf32("A32"), 
5967                         new System.Text.Parsing.CharParser(',')))));
5968             AddRule(new ConversionFunctionIdRule(ToUtf32("ConversionFunctionId"), GetScope(), Domain()->GetNextRuleId(), 
5969                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5970                     new System.Text.Parsing.GroupingParser(
5971                         new System.Text.Parsing.SequenceParser(
5972                             new System.Text.Parsing.KeywordParser(ToUtf32("operator")), 
5973                             new System.Text.Parsing.NonterminalParser(ToUtf32("TypeExpr"), ToUtf32("TypeExpr"), 1))))));
5974             AddRule(new LambdaExpressionRule(ToUtf32("LambdaExpression"), GetScope(), Domain()->GetNextRuleId(), 
5975                 new System.Text.Parsing.SequenceParser(
5976                     new System.Text.Parsing.SequenceParser(
5977                         new System.Text.Parsing.SequenceParser(
5978                             new System.Text.Parsing.SequenceParser(
5979                                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5980                                     new System.Text.Parsing.CharParser('[')), 
5981                                 new System.Text.Parsing.NonterminalParser(ToUtf32("LambdaCaptures"), ToUtf32("LambdaCaptures"), 1)), 
5982                             new System.Text.Parsing.ExpectationParser(
5983                                 new System.Text.Parsing.CharParser(']'))), 
5984                         new System.Text.Parsing.OptionalParser(
5985                             new System.Text.Parsing.GroupingParser(
5986                                 new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
5987                                     new System.Text.Parsing.NonterminalParser(ToUtf32("ParameterList"), ToUtf32("ParameterList"), 1))))), 
5988                     new System.Text.Parsing.ExpectationParser(
5989                         new System.Text.Parsing.GroupingParser(
5990                             new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
5991                                 new System.Text.Parsing.NonterminalParser(ToUtf32("CompoundStatement"), ToUtf32("CompoundStatement"), 1)))))));
5992             AddRule(new LambdaCapturesRule(ToUtf32("LambdaCaptures"), GetScope(), Domain()->GetNextRuleId(), 
5993                 new System.Text.Parsing.SequenceParser(
5994                     new System.Text.Parsing.OptionalParser(
5995                         new System.Text.Parsing.GroupingParser(
5996                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
5997                                 new System.Text.Parsing.NonterminalParser(ToUtf32("CaptureDefault"), ToUtf32("CaptureDefault"), 0)))), 
5998                     new System.Text.Parsing.OptionalParser(
5999                         new System.Text.Parsing.NonterminalParser(ToUtf32("Captures"), ToUtf32("Captures"), 1)))));
6000             AddRule(new CaptureDefaultRule(ToUtf32("CaptureDefault"), GetScope(), Domain()->GetNextRuleId(), 
6001                 new System.Text.Parsing.AlternativeParser(
6002                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
6003                         new System.Text.Parsing.CharParser('=')), 
6004                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
6005                         new System.Text.Parsing.CharParser('&')))));
6006             AddRule(new CapturesRule(ToUtf32("Captures"), GetScope(), Domain()->GetNextRuleId(), 
6007                 new System.Text.Parsing.SequenceParser(
6008                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
6009                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Capture"), 0)), 
6010                     new System.Text.Parsing.KleeneStarParser(
6011                         new System.Text.Parsing.GroupingParser(
6012                             new System.Text.Parsing.SequenceParser(
6013                                 new System.Text.Parsing.CharParser(','), 
6014                                 new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
6015                                     new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Capture"), 0))))))));
6016             AddRule(new CaptureRule(ToUtf32("Capture"), GetScope(), Domain()->GetNextRuleId(), 
6017                 new System.Text.Parsing.AlternativeParser(
6018                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
6019                         new System.Text.Parsing.NonterminalParser(ToUtf32("Identifier"), ToUtf32("Identifier"), 0)), 
6020                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
6021                         new System.Text.Parsing.KeywordParser(ToUtf32("this"))))));
6022         }
6023     }
6024 } // cppparser
6025 namespace cppparser
6026 {
6027     public class ConstantExpressionGrammar : System.Text.Parsing.Grammar
6028     {
6029         public ConstantExpressionGrammar() : this(new ParsingDomain())
6030         {
6031         }
6032         public ConstantExpressionGrammar(ParsingDomain* parsingDomain) : base(ToUtf32("ConstantExpressionGrammar"), parsingDomain->GetNamespaceScope(ToUtf32("cppparser")), parsingDomain)
6033         {
6034             SetOwner(0);
6035             RegisterParsingDomain(parsingDomain);
6036             parsingDomain->AddGrammar(this);
6037             CreateRules();
6038             Link();
6039         }
6040         public Node* Parse(const uchar* start, const uchar* end, int fileIndex, const string& fileName, ParsingContext* ctx)
6041         {
6042             Scanner scanner(start, end, fileName, fileIndex, SkipRule());
6043             UniquePtr<XmlLog> xmlLog;
6044             if (Log() != null)
6045             {
6046                 xmlLog.Reset(new XmlLog(*Log(), MaxLogLineLength()));
6047                 scanner.SetLog(xmlLog.Get());
6048                 xmlLog->WriteBeginRule( u"parse");
6049                 xmlLog->IncIndent();
6050             }
6051             Stack<UniquePtr<Object>> stack;
6052             UniquePtr<ParsingData> parsingData(new ParsingData(Domain()->NumRules()));
6053             scanner.SetParsingData(parsingData.Get());
6054             stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(ctx)));
6055             Match match = base->Parse(scanner, stack, parsingData.Get());
6056             Span stop = scanner.GetSpan();
6057             if (Log() != null)
6058             {
6059                 xmlLog->DecIndent();
6060                 xmlLog->WriteEndRule( u"parse");
6061             }
6062             if (!match.Hit() || stop.start != cast<int>(end - start))
6063             {
6064                 if (StartRule() != null)
6065                 {
6066                     throw ExpectationFailure(StartRule()->Info(), fileName, stop, start, end);
6067                 }
6068                 else
6069                 {
6070                     throw ParsingException("grammar '" + ToUtf8(Name()) + "' has no start rule", fileName, scanner.GetSpan(), start, end);
6071                 }
6072             }
6073             UniquePtr<Object> value = stack.Pop();
6074             Node* result = *cast<ValueObject<Node*>*>(value.Get());
6075             return result;
6076         }
6077 
6078         public override void GetReferencedGrammars()
6079         {
6080             ParsingDomain* pd = Domain();
6081             Grammar* grammar0 = pd->GetGrammar(ToUtf32("cppparser.ExpressionGrammar"));
6082             if (grammar0 == null)
6083             {
6084                 grammar0 = new cppparser.ExpressionGrammar(pd);
6085             }
6086             AddGrammarReference(grammar0);
6087             Grammar* grammar1 = pd->GetGrammar(ToUtf32("System.Text.Parsing.stdlib"));
6088             if (grammar1 == null)
6089             {
6090                 grammar1 = new System.Text.Parsing.stdlib(pd);
6091             }
6092             AddGrammarReference(grammar1);
6093         }
6094         public override void CreateRules()
6095         {
6096             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("ConstantExpression"), this, ToUtf32("ExpressionGrammar.ConstantExpression")));
6097             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("spaces"), this, ToUtf32("System.Text.Parsing.stdlib.spaces")));
6098             SetStartRuleName(ToUtf32("ConstantExpression"));
6099             SetSkipRuleName(ToUtf32("spaces"));
6100         }
6101     }
6102 } // cppparser